diff --git a/README.md b/README.md
index 025b300..df29bb0 100644
--- a/README.md
+++ b/README.md
@@ -7,7 +7,7 @@
 
 **English**: [README_EN.md](README_EN.md)
 
-[DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness) 插件：**论文伴读工作台** —— 文献库 + PDF 阅读器 + AI 伴读，回答自带页码、点页码跳回原文。当前版本 **v1.4.1**。
+[DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness) 插件：**论文伴读工作台** —— 文献库 + PDF 阅读器 + AI 伴读，回答自带页码、点页码跳回原文。当前版本 **v1.5.0**。
 
 > 💬 **QQ 交流群：1127244508** —— 安装/使用问题、功能建议、bug 反馈都欢迎来聊。
 
@@ -24,6 +24,8 @@
 - 🤖 **教练式带读**：paper 会话自动用专用 preset——定分步阅读计划、逐节指导、出题批改，学习进度跨会话累积
 - 🀄 **中文版**：原文 ↔ 纯中文原地切换（babeldoc 零预装，自动安装），译文 PDF 一键导出（纯中文 / 中英对照）
 - 🗂️ **文献管理**：专题/论文改名、删除（删除前列文件清单、进回收站**可恢复**、非空专题批量清空一次确认）
+- 🈯 **划词翻译（公式保留）**（v1.5.0）：阅读器里选中正文 → 提问气泡上多一个 **「译」** 按钮 → 弹出**只显示译文**的气泡（**没有**「插入会话」「复制」按钮，也从不自动写剪贴板）。**选区含公式时**，用 MinerU 识别出的 LaTeX 替换 PDF 文本层里的乱码公式，并要求模型**原样保留**公式（`$…$` 里的内容不翻译、不改写）。**前提与代价**：① 需先配置翻译端点（与生成中文版用的是同一份配置；未配置时点「译」会直接弹设置表单，保存后自动重试）；② **公式保留要求该论文用 MinerU 转录过**——没有产物时**降级为普通翻译**，公式在文本层里本就不读，气泡会**如实提示「译文可能不准」**（这是设计，不是缺陷）
+- 🖥️ **中英分屏对照（两种模式，可切换）**（v1.5.0）：顶栏新增 **「对照」** 与 **「分屏」** 两个按钮，随时切换、再点一次回原文，选择按文献记忆。**模式 A「对照」** 直接看 babeldoc 的 `-dual.pdf`（原文与译文并排画在同一张加宽页面上，自动适宽）；**模式 B「分屏」** 左原文、右中文版，两列**同步滚动**（同页号 + 页内比例）。**前提与代价**：模式 A 需要 `-dual.pdf`、模式 B 需要 `-zh.pdf`，两者都要先用 babeldoc 生成（顶栏「中」一键触发，**首次约几分钟**，且需要翻译端点）；**没有对应产物时按钮置灰并说明**；分屏需要面板宽度 ≥640px，太窄会提示而不切换
 - ➕ **两个可选增强**（默认关，见「进阶」）：MinerU 解析——扫描件可读、公式可点引用可检索；语义检索端点——大白话命中术语段落
 
 安装后**不改动官方界面**：侧栏底部多一行「📚 论文伴读」开关，点击才进入伴读模式，再点即还原。
@@ -68,6 +70,7 @@ dsh plugin --profile web add @ggboy123/dsh-paper-reader@latest
 
 ```bash
 dsh plugin --profile web add @ggboy123/dsh-paper-reader@latest   # 永远装最新
+# dsh plugin --profile web add @ggboy123/dsh-paper-reader@1.5.0  # 或钉住具体版本
 grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/package.json   # 查当前版本
 # 重启 dsh web 生效；浏览器 Cmd+Shift+R 强刷，避免旧阅读器页面缓存
 ```
@@ -88,7 +91,7 @@ grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/pac
 默认用本地 pdf.js 提取文本——**普通文本型 PDF 完全够用，什么都不用配**。两类场景需要 MinerU：
 
 - **扫描版 PDF**（老论文、书章、扫描讲义）：没有文本层，pdf.js 读不了，MinerU（OCR）能读
-- **公式**：PDF 里公式是图形乱码，选不中也搜不到。**公式引用**——MinerU 把公式识别成 LaTeX 后，点 PDF 上的公式即引用进对话提问；`QK^T` 这类公式检索也能命中；顶栏「∑ 公式」面板按页浏览全文公式
+- **公式引用**：PDF 里公式是图形乱码，选不中也搜不到。MinerU 把公式识别成 LaTeX 后，**点 PDF 上的公式会把该公式的 LaTeX 带进提问气泡**（发送即随问题引用进对话）；`QK^T` 这类公式检索也能命中；顶栏「∑ 公式」面板按页浏览全文公式
 
 **需要自己准备（二选一）**，在 **设置 → 论文伴读 → 「MinerU 解析后端」** 里配置：
 
@@ -120,6 +123,50 @@ grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/pac
 - 改名后：转录缓存/译文/学习档案全部跟随搬家；历史伴读会话**本体保留**但不再挂在新名字下（会话 id 编码旧名）；纯大小写改名在 macOS/Windows 可用
 - 手工放进 `data/` 的怪名字文件（如 `.hidden.pdf`）也能正常删除/改名，不会成为孤儿
 
+## 划词翻译与中英分屏对照（v1.5.0）
+
+### 划词翻译（公式保留）
+
+**怎么用**：在阅读器里**选中一段正文** → 弹出「选中即问」气泡（行为与以前完全一致）→ 点气泡里的 **「译」** → 弹出**译文气泡**，里面**只有译文**（外加一行诚实提示）。想重翻就重新选一次；点气泡外或按 Esc 关掉。
+
+译文气泡里**没有**「插入会话」「复制」按钮（按你的要求），也**从不**自动写剪贴板。提问链路一点没动：重新选一次字就回到原来的提问气泡。
+
+**公式是怎么处理的**（这是本功能的核心）：
+
+- PDF 文本层里的公式**不可读**：`$F_{\theta}$` 常常只剩一个 `F`（下标整字丢失）、`\sum` 变成 `X`、分式被拉平成一行、括号对甚至变成控制字符。把这串东西直接发给模型，译文里的公式必然错。
+- 所以：**选区里的公式先用 MinerU 的 LaTeX 把那一段乱码替换掉**，再明确要求模型**原样保留** `$…$` 里的内容（不翻译、不改写、不省略、不增删符号）。译文回来后还会**逐个公式核对**是否原样保留，缺了就在气泡里如实告诉你。
+- 两类公式都覆盖：**独立成行的公式**（用 MinerU `equation` 块的 bbox 精确定位）与**正文里穿插的行内公式**（如 `π(a|s)`、`Q(s,a)`、`x_t`）。行内公式在 MinerU 产物里**没有自己的 bbox**（它嵌在正文块里），插件靠「选区文本 ↔ MinerU 块文本」的模糊对齐把它还原出来。
+
+**前提与代价（务必先读）**：
+
+| # | 前提 | 没有它会怎样 |
+| --- | --- | --- |
+| 1 | **需要先配置翻译端点**（设置 → 论文伴读，或阅读器右上角 ⚙；与生成中文版共用同一份配置） | 点「译」会**自动弹出端点设置表单**；填好保存后**自动重试这次翻译**（不会白点一次）。端点三项不齐时服务端直接拒绝，前端据此弹表单 |
+| 2 | **公式保留需要该论文用 MinerU 转录过**（存在 `<文献>.mineru.json`） | **降级为普通翻译**：正文照常翻，但公式在文本层里本就不读，气泡会如实提示「该论文未用 MinerU 转录：原文里的公式在文本层不可读，译文可能不准」。**这是设计，不是缺陷** |
+| 3 | 有 MinerU 产物、但某一段公式没对上 | 只还原能对上的部分，气泡提示「部分公式未能还原，译文可能不准」 |
+| 4 | 选区太短（不足 4 个有效字符，例如只选中孤零零的 `F`） | 不做还原（不足以判别），气泡提示「选区太短，公式未还原」 |
+
+**已知限制（如实声明，不粉饰）**：
+
+- **未对真实 LLM 端点打过任何请求**：开发期验证全程使用假上游（避免花钱、避免用你的 key）。「模型是否真的原样保留公式」目前靠**提示词字节契约**＋**回包逐公式核对**两道可判定断言保证，没有真实服务商 key 的端到端实测。
+- MinerU 偶尔会把**一个公式拆成两个 `$…$`**（首个片段以 `=` 结尾）。这种形态下可能只还原出半截公式（如 `action $\hat{a}_t\sim\pi_\theta(\cdot\ |$`），`$` 配对计数拦不住；本机语料里未出现，留待后续。
+- 选区里含**字面** `$`（正文里真印了一个美元符号）时，极端形态下可能产生一句「有 N 个公式未原样保留」的**误报提示**（已记录，不影响译文本身）。
+- 中文版 / 对照视图下**不做**公式替换（bbox 只对原文页成立），所以「译」按钮只在原文视图出现。
+
+### 中英分屏对照（两种模式）
+
+顶栏新增两个按钮，随时切换、**再点一次回原文**；每篇文献上次用的视图会被记住（跟着文献走，改名也不丢）：
+
+| 按钮 | 模式 | 看的是哪个文件 | 前提 |
+| --- | --- | --- | --- |
+| **对照** | A：单页内对照 | babeldoc 的 `-dual.pdf`（原文与译文并排画在同一张加宽页上，页宽约 2 倍） | 需要 `-dual.pdf` |
+| **分屏** | B：左右并排 | 左：原文 `<文献>.pdf`；右：`<文献>-zh.pdf` | 需要 `-zh.pdf` |
+
+- **两个产物都要先用 babeldoc 生成**：顶栏点「中」一键触发（**首次要装引擎 + 翻译，约几分钟**，需要翻译端点）。没有对应产物时按钮**置灰并写明原因**，不会点了没反应。
+- **同步滚动**：滚任意一列，另一列自动跟到「同一页号 + 同一页内比例」；谁在滚谁主导，不会两列互相拉锯。翻页模式（`▣`）下两列同步同页。**中文版与原文页数不一致时按比例映射**，并在状态栏给出一次性提示。
+- **分屏宽度**：需要面板宽度 ≥640px；太窄时点「分屏」只提示「请把阅读器拉宽」，**不会**切进去；分屏期间把面板缩到 640px 以下会自动退回原文。
+- **与既有能力的关系**：分屏时左列就是普通原文视图——**公式热区照常可点**（右列不参与命中，也不会被画上热区）；公式面板照常可用；「中」按钮在分屏期间置灰（避免与分屏语义打架）。切到中文 / 对照视图时热区仍按既有规则关闭（bbox 只对原文页成立）。
+
 ## 参与开发
 
 ```bash
@@ -154,6 +201,7 @@ src/
   study.ts      纯函数：学习档案（计划 + 检验成绩）读写
   translate.ts  纯函数：babeldoc 调用（中文/中英对照 PDF 生成）
   babeldoc-install.ts 纯函数：无 Python 环境时自动安装 babeldoc（uv → 托管 Python → venv）
+  translate-selection.ts 纯函数：划词翻译（公式保留 —— 行内公式与 MinerU 块文本对齐还原、请求体与提示词契约、逐公式保全校验、内存 LRU 缓存）
   rerank.ts     纯函数：search_paper 语义重排（TypeSafe/Jev，无凭据时退回关键词排序）
   preset.ts     纯函数：自带 agent preset 安装到 $DSH_HOME/.agent-presets/
 presets/paper-reader/  「论文伴读」agent preset（persona 完整提示词 + compaction）
diff --git a/README_EN.md b/README_EN.md
index 43cefe4..3dded2f 100644
--- a/README_EN.md
+++ b/README_EN.md
@@ -7,7 +7,7 @@
 
 **中文**: [README.md](README.md)
 
-A [DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness) plugin: a **paper reading workbench** — paper library + PDF reader + AI companion. Every answer cites page numbers, and clicking a page jumps back to the exact highlighted passage. Current version: **v1.4.1**.
+A [DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness) plugin: a **paper reading workbench** — paper library + PDF reader + AI companion. Every answer cites page numbers, and clicking a page jumps back to the exact highlighted passage. Current version: **v1.5.0**.
 
 > 💬 **QQ group: 1127244508** — questions, feature requests, and bug reports are all welcome.
 
@@ -24,6 +24,8 @@ A [DeepSeek Harness (dsh)](https://github.com/deepseek-ai/deepseek-harness) plug
 - 🤖 **Tutor mode**: paper sessions automatically use a dedicated preset — step-by-step reading plans, section-by-section coaching, graded quizzes; progress accumulates across sessions
 - 🀄 **Chinese version**: original ↔ full-Chinese in-place toggle (babeldoc auto-installed, zero preinstall); one-click export (Chinese / bilingual PDF)
 - 🗂️ **Library management**: rename/delete topics and papers (deletion shows a file manifest first, goes to a **recoverable** trash; non-empty topics support batch-clear with one confirmation)
+- 🈯 **Selection translation (formulas preserved)** (v1.5.0): select text in the reader → the ask bubble gains a **"译" (Translate)** button → a **translation-only** bubble opens (there is **no** "insert into chat" and **no** "copy" button, and the plugin never writes to your clipboard on its own). **When the selection overlaps a formula**, the plugin replaces the garbage formula glyphs in the PDF text layer with the LaTeX MinerU recognized and asks the model to **keep formulas verbatim** (nothing inside `$…$` is translated or rewritten). **Costs and prerequisites**: ① you must configure the translation endpoint first (the same config the Chinese-PDF generation uses; with nothing configured, clicking "译" opens the endpoint form and retries automatically after saving); ② **formula preservation requires that paper to have been parsed by MinerU** — without an artifact it **falls back to plain translation**, and since formulas are unreadable in the text layer the bubble **says so honestly** ("translation may be inaccurate"). That is by design, not a defect.
+- 🖥️ **Bilingual split view (two modes, switchable)** (v1.5.0): two new toolbar buttons, **"对照" (Side-by-side page)** and **"分屏" (Split)** — switch any time, click again to go back to the original; the choice is remembered per paper. **Mode A 「对照」** shows babeldoc's `-dual.pdf` (original and translation laid out on the same doubled-width page, auto fit-width); **Mode B 「分屏」** puts the original on the left and `<paper>-zh.pdf` on the right with **synchronised scrolling** (same page + same in-page ratio). **Costs and prerequisites**: mode A needs `-dual.pdf` and mode B needs `-zh.pdf`; both are produced by babeldoc (click "中" in the toolbar — **the first run takes a few minutes** and needs the translation endpoint); **without the artifact the button is greyed out with an explanation**; the split view needs a panel at least 640px wide — narrower than that it explains instead of switching.
 - ➕ **Two optional add-ons** (off by default, see "Advanced"): MinerU parsing — scanned PDFs become readable, formulas become click-citable and searchable; an embeddings endpoint — plain-language semantic search
 
 Installing **does not modify the official UI**: a single "📚 Paper Reading" toggle appears at the bottom of the sidebar; click to enter reading mode, click again to restore.
@@ -68,6 +70,7 @@ dsh plugin --profile web add @ggboy123/dsh-paper-reader@latest
 
 ```bash
 dsh plugin --profile web add @ggboy123/dsh-paper-reader@latest   # always newest
+# dsh plugin --profile web add @ggboy123/dsh-paper-reader@1.5.0  # or pin a version
 grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/package.json   # check current version
 # Restart dsh web; hard-refresh the browser (Cmd+Shift+R) to avoid cached reader pages
 ```
@@ -77,7 +80,7 @@ grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/pac
 1. **Enter**: click "📚 Paper Reading" at the bottom of the sidebar — it becomes the library tree (click again to restore the official workspace list)
 2. **Add papers**: ＋ create a topic → ⬆ upload PDFs (with an empty library, "Upload PDF" auto-creates a default topic)
 3. **Read + ask**: click a paper — reader in the middle, chat on the right. Ask in the input box (no need to name the paper; answers cite pages), or **select text** in the reader for a pop-up question box; click "page N" in an answer to jump back
-4. **Chinese version**: the "中" button — one click generates a translation if none exists (first use auto-installs the engine; fill in an OpenAI-compatible endpoint once — DeepSeek/GLM/Kimi keys all work); ⤓ downloads the version you're viewing; ▣ toggles single-page mode
+4. **Chinese version**: the "中" button — one click generates a translation if none exists (first use auto-installs the engine; fill in an OpenAI-compatible endpoint once — DeepSeek/GLM/Kimi keys all work); ⤓ downloads the version you're viewing; ▣ toggles single-page mode ↔ scroll
 5. **Manage**: hover a row for ✎ rename / 🗑 delete. Deletion lists the files first, then moves them to a **recoverable trash** (`data/.trash/`); deleting a non-empty topic = batch-clear with one confirmation
 6. **Chats**: 🕐 in the chat header shows that paper's history; ＋ starts a new conversation
 
@@ -88,7 +91,7 @@ grep '"version"' ~/.dsh/profiles/web/node_modules/@ggboy123/dsh-paper-reader/pac
 By default text is extracted locally with pdf.js — **plain text-native PDFs need no configuration at all**. Two scenarios need MinerU:
 
 - **Scanned PDFs** (old papers, book chapters, scanned handouts): no text layer, pdf.js can't read them; MinerU (OCR) can
-- **Formulas**: formulas in PDFs are graphical garbage — unselectable and unsearchable. Once MinerU recovers them as LaTeX, **click a formula and its LaTeX is cited straight into the chat**; formula queries like `QK^T` hit search; the "∑ 公式" panel lists every formula by page
+- **Click to cite a formula**: formulas in PDFs are graphical garbage — unselectable and unsearchable. Once MinerU recovers them as LaTeX, **clicking a formula in the PDF puts its LaTeX into the ask bubble** (send it and the formula is cited with your question); formula queries like `QK^T` hit search; the "∑ 公式" (Formulas) panel lists every formula by page
 
 **You need to set this up yourself (pick one)**, configured under **Settings → Paper Reader → "MinerU parser"**:
 
@@ -120,6 +123,50 @@ Configure one of three ways (same priority as the translate endpoint): the setti
 - After a rename: transcripts/translations/study profiles move along; past chat sessions are **kept** but no longer listed under the new name (session ids encode the old name); case-only renames work on macOS/Windows
 - Oddly named files placed into `data/` by hand (e.g. `.hidden.pdf`) can still be deleted/renamed — nothing becomes a visible-but-undeletable orphan
 
+## Selection translation and bilingual split view (v1.5.0)
+
+### Selection translation (formulas preserved)
+
+**How to use**: select a passage in the reader → the familiar "select-to-ask" bubble appears (behaviour unchanged) → click **"译" (Translate)** → a **translation bubble** opens containing **only the translation** (plus one honest note line). Re-select to retranslate; click outside or press Esc to dismiss.
+
+That bubble has **no** "insert into chat" and **no** "copy" button (as requested), and the plugin **never** writes to your clipboard automatically. The asking path is untouched: just select again and you are back in the original ask bubble.
+
+**What happens to formulas** (the core of this feature):
+
+- Formulas in the PDF text layer are **unreadable**: `$F_{\theta}$` often degrades to a bare `F` (the subscript is dropped entirely), `\sum` becomes `X`, fractions get flattened into one line, and delimiter pairs can even turn into control characters. Feeding that to a model guarantees wrong formulas in the translation.
+- So: **each formula inside the selection is replaced by the LaTeX MinerU recognized**, and the model is explicitly told to **keep `$…$` verbatim** (no translation, no rewriting, no omissions, no added symbols). When the reply comes back, every formula token is **checked** to still be present, and the bubble tells you honestly if any went missing.
+- Both kinds are covered: **display formulas** (located exactly with the MinerU `equation` block bbox) and **inline formulas embedded in prose** (e.g. `π(a|s)`, `Q(s,a)`, `x_t`). Inline formulas have **no bbox of their own** in MinerU's output (they live inside a text block), so the plugin recovers them by fuzzy-aligning the selection text against the MinerU block text.
+
+**Prerequisites and costs (please read first)**:
+
+| # | Prerequisite | What happens without it |
+| --- | --- | --- |
+| 1 | **A configured translation endpoint** (Settings → Paper Reader, or ⚙ in the reader toolbar; the same config used for Chinese-PDF generation) | Clicking "译" **opens the endpoint form automatically**, and **retries this translation** after you save (no wasted click). If the endpoint is incomplete the server refuses and the UI opens that form |
+| 2 | **Formula preservation requires the paper to have been parsed by MinerU** (a `<paper>.mineru.json` artifact) | **Falls back to plain translation**: prose is translated normally, but formulas are unreadable in the text layer, so the bubble honestly says "this paper was not parsed with MinerU: the translation may be inaccurate". **By design, not a defect** |
+| 3 | An artifact exists but one passage could not be aligned | Only the alignable parts are restored; the bubble says "some formulas could not be restored" |
+| 4 | A very short selection (fewer than 4 effective characters, e.g. the lone `F`) | No restoration (not enough signal); the bubble says "selection too short, formula not restored" |
+
+**Known limitations (stated plainly, not glossed over)**:
+
+- **No request has ever been sent to a real LLM endpoint**: all development verification used a fake upstream (to avoid spending money and to avoid using your key). "Does the model really keep formulas verbatim" is backed by two decidable assertions — a **byte-level prompt contract** and a **per-formula check on the reply** — but there is no end-to-end run against a real provider key.
+- MinerU occasionally splits **one formula into two `$…$` fragments** (the first ending in `=`). In that shape only half a formula may be restored (e.g. `action $\hat{a}_t\sim\pi_\theta(\cdot\ |$`); the `$`-pairing check cannot catch it. Not observed in the local corpus; left for follow-up.
+- A **literal `$`** inside the selection (a real dollar sign printed in the text) can, in an extreme shape, produce a false "N formulas were not preserved" note. Recorded; it does not affect the translation itself.
+- **No formula replacement in the Chinese / dual views** (the bbox only holds for original pages), which is why the "译" button only appears in the original view.
+
+### Bilingual split view (two modes)
+
+Two new toolbar buttons; switch any time and **click again to return to the original**. Each paper remembers its last view (and the memory follows the paper across renames):
+
+| Button | Mode | What you are looking at | Prerequisite |
+| --- | --- | --- | --- |
+| **对照** | A: side-by-side page | babeldoc's `-dual.pdf` (original + translation on one doubled-width page) | needs `-dual.pdf` |
+| **分屏** | B: two panes | left: original `<paper>.pdf`; right: `<paper>-zh.pdf` | needs `-zh.pdf` |
+
+- **Both artifacts come from babeldoc**: click "中" in the toolbar (**the first run installs the engine and translates — a few minutes**, and needs the translation endpoint). If the artifact is missing the button is **greyed out with the reason stated** — never a dead click.
+- **Synchronised scrolling**: scrolling either pane moves the other to the **same page + same in-page ratio**; whichever pane you are scrolling leads, so the two never fight each other. In paged mode (`▣`) both panes show the same page. **If the Chinese PDF has a different page count, the panes are mapped proportionally** and a one-off notice appears in the status bar.
+- **Width**: the split view needs a panel at least **640px** wide; narrower, clicking "分屏" only explains and does **not** switch. Shrinking below 640px while split falls back to the original automatically.
+- **Interaction with existing features**: while split, the left pane is the ordinary original view — **formula hotspots stay clickable** (the right pane neither participates in hit-testing nor gets a hotspot layer), the formula panel keeps working, and the "中" toggle is disabled during split (to avoid conflicting semantics). Switching to the Chinese / dual view still disables hotspots, exactly as before (the bbox only holds for original pages).
+
 ## Contributing
 
 ```bash
@@ -154,6 +201,7 @@ src/
   study.ts      pure functions: study profile (plan + quiz scores) I/O
   translate.ts  pure functions: babeldoc invocation (Chinese / bilingual PDF generation)
   babeldoc-install.ts pure functions: auto-install babeldoc without a Python env (uv → managed Python → venv)
+  translate-selection.ts pure functions: selection translation with formula preservation (aligns inline formulas against MinerU block text, prompt/request-body contract, per-formula preservation check, in-memory LRU cache)
   rerank.ts     pure functions: search_paper semantic rerank (TypeSafe/Jev; falls back to keyword ranking)
   preset.ts     pure functions: installs the bundled agent preset into $DSH_HOME/.agent-presets/
 presets/paper-reader/  the "Paper Tutor" agent preset (full persona prompt + compaction)
diff --git a/lib/client.js b/lib/client.js
index 95c9d7b..b6f01a3 100644
--- a/lib/client.js
+++ b/lib/client.js
@@ -39,6 +39,22 @@ function clearFailureText(err, t) {
   }
 }
 
+/**
+ * 分屏「同步滚动」偏好 —— **纯函数**（文件顶层：Node 里执行本文件即可取用，测试 harness 追加导出）。
+ * 与 `reader/index.html` 里的同键读写必须保持同一套编码，所以两边都只认 `'1'` / `'0'`。
+ *
+ * 键为什么长这样（`dpr.syncScroll`：无 topic/name、也不带 `dpr.variant.` 前缀）：
+ *   ① 用户明确要求**全局**（所有论文共用一个值，不按篇记）；
+ *   ② `migrateLsKeys`（改名搬家）只搬 `dpr.variant.` / `dpr.sessionN.` 两个前缀 ⇒ 这个键既不会被搬
+ *      也不会被删，论文/专题改名**不可能**让偏好丢失（全局键本来就没有「跟着某篇走」的身份）。
+ *      反例：若塞进 `dpr.variant.<topic>/<name>`（按篇），改名搬家会搬它，而「全局」语义就破了。
+ *   ③ 缺省 = 开：与改造前「分屏两列被 rAF 强行同步」的既有行为一致（老用户升级后观感不变）。
+ */
+const DPR_SYNC_SCROLL_KEY = 'dpr.syncScroll'
+/** 只认显式的 '0' 为关；缺失 / 脏值 / 隐私模式都算开（与 reader 的 readSyncPref 逐字同义）。 */
+function dprSyncScrollFromRaw(raw) { return raw !== '0' }
+function dprSyncScrollRaw(on) { return on ? '1' : '0' }
+
 window.__ModuleLoader__.load({
   // 必须等于 npm 包名：浏览器端 loader 按包名期待注册（改名时漏改这里 →
   // "loaded without registering" 整页插件加载失败，实测）
@@ -86,6 +102,13 @@ window.__ModuleLoader__.load({
       setMineruWhyLocal: '本地模式需要你自己跑一个 MinerU 服务（127.0.0.1:8000），适合有显卡、论文不外传的场景。',
       setMineruWhyCloud: '云端模式只要一个 mineru.net token，无需本地显卡；论文会上传到 mineru.net 解析。',
       setMineruOffHint: '当前为「关闭」：转录走本地 pdf.js——有文本层的普通 PDF 完全够用；扫描版（没有文本层）与公式引用才需要 MinerU（选本地或云端）。',
+      // 分屏「同步滚动」（模式 B 的全局偏好）：与阅读器分屏控件旁的那个开关是**同一个值**
+      // （键 dpr.syncScroll，见文件顶层的纯函数），任一处改动另一处立即跟着变。
+      setSyncScrollTitle: '分屏同步滚动',
+      setSyncScrollDesc: '阅读器里「分屏」对照（模式 B：原文 PDF ↔ 中文版 PDF 两列）时，两列是否一起滚动。关闭后两列各自独立滚动（适合对照着看不同页）；重新打开会自动把两列对齐回当前页，不会停在两页上。全局偏好：所有论文共用一个值，不按篇记；默认开。模式 A（babeldoc 的中英对照 PDF）只有一个滚动条，不受此项影响。',
+      setSyncScrollLabel: '分屏两列同步滚动',
+      setSyncScrollOnHint: '当前：开 —— 两列一起滚动（默认）',
+      setSyncScrollOffHint: '当前：关 —— 两列各自独立滚动；再打开时会自动对齐回当前页',
       // 文献管理（删除/重命名）：契约见 docs/reader-ux-requirements.md §2.9。
       // 去重说明：rename/renameTopic/renamePaper/renameFail/delFail 只保留上面上游那组
       // （JS 对象字面量重复 key 不报错、后者静默胜出 → 必须手工去重，否则文案悄悄取自另一份）。
@@ -158,6 +181,11 @@ window.__ModuleLoader__.load({
       setMineruWhyLocal: 'Local mode expects your own MinerU service (127.0.0.1:8000) — for GPUs and papers that should stay on your machine.',
       setMineruWhyCloud: 'Cloud mode needs only a mineru.net token and no local GPU; the paper is uploaded to mineru.net for parsing.',
       setMineruOffHint: 'Currently Off: transcription uses local pdf.js — fine for PDFs that already have a text layer; scanned PDFs (no text layer) and formula citing need MinerU (local or cloud).',
+      setSyncScrollTitle: 'Split-view sync scrolling',
+      setSyncScrollDesc: 'In the reader split view (mode B: the original PDF next to the translated -zh.pdf) — should the two columns scroll together? Off: each column scrolls independently (handy to compare different pages); turning it back on realigns both columns to the current page instead of leaving them on different pages. Global preference: one value for every paper, never per paper; on by default. Mode A (babeldoc dual PDF) has a single scrollbar and is unaffected.',
+      setSyncScrollLabel: 'Scroll the two split columns together',
+      setSyncScrollOnHint: 'Currently: on — the two columns scroll together (default)',
+      setSyncScrollOffHint: 'Currently: off — the two columns scroll independently; turning it on realigns them to the current page',
       newName: 'New name', renameDone: 'Renamed',
       renameDetached: 'Note: {n} past chats are kept but no longer listed',
       renameTargetExists: 'A paper or topic with that name already exists',
@@ -1418,6 +1446,47 @@ window.__ModuleLoader__.load({
       )
     }
 
+    /* ---------- 分屏同步滚动卡片（模式 B 的**全局**偏好）----------
+       本卡片与阅读器是**两个文档**（阅读器是同源 iframe ~ /paper-reader/），共享同一个 localStorage：
+         · 这里勾/取消 → 写 `dpr.syncScroll` → 阅读器收到 storage 事件 → 开关与滚动行为立即跟着变
+           （打开时还会自动把两列对齐回当前页）；
+         · 反之在阅读器「分屏」控件旁点开关 → 这里收到 storage 事件 → 勾选态立即跟着变。
+       ⇒ 两处入口互相同步，且都是**同一个键**（键名与 '1'/'0' 编码由文件顶层的纯函数定义，
+          与 reader/index.html 逐字一致）。默认开 = 缺省值（与改造前行为一致）。 */
+    function SyncScrollCard() {
+      const readPref = () => { try { return dprSyncScrollFromRaw(localStorage.getItem(DPR_SYNC_SCROLL_KEY)) } catch { return true } }
+      const [on, setOn] = useState(readPref)
+      useEffect(() => {
+        const onStorage = (e) => {
+          if (!e || e.key !== DPR_SYNC_SCROLL_KEY) return
+          setOn(dprSyncScrollFromRaw(e.newValue))   // 另一处（阅读器/另一个窗口）改了 → 立即反映
+        }
+        window.addEventListener('storage', onStorage)
+        return () => window.removeEventListener('storage', onStorage)
+      }, [])
+      const apply = (v) => {
+        setOn(v)
+        try { localStorage.setItem(DPR_SYNC_SCROLL_KEY, dprSyncScrollRaw(v)) } catch { /* 隐私模式写不了：阅读器里仍可单独改 */ }
+      }
+      return h('div', { style: SET.card, 'data-dsh-plugin': 'dsh-paper-reader', 'data-dsh-part': 'settings-card' },
+        h('h3', { style: SET.title }, t('setSyncScrollTitle')),
+        h('p', { style: SET.desc }, t('setSyncScrollDesc')),
+        h('div', { style: SET.row },
+          h('label', { style: { ...SET.label, display: 'flex', alignItems: 'center', gap: '8px', margin: '0' }, 'data-dpr-sync-label': '' },
+            h('input', {
+              type: 'checkbox', checked: on, 'data-dpr-sync-input': '',
+              // 与面板主题色对齐（原生 checkbox 的默认蓝与每套主题都对不上）：accent-color 是标准
+              // 属性，不支持的旧壳只是回落成默认色，不影响可用性
+              style: { width: '16px', height: '16px', cursor: 'pointer', accentColor: 'var(--dsw-alias-button-primary-fill, #1f6feb)' },
+              onChange: (e) => apply(!!e.target.checked),
+            }),
+            t('setSyncScrollLabel'),
+          ),
+          h('span', { style: SET.meta, 'data-dpr-sync-state': '' }, on ? t('setSyncScrollOnHint') : t('setSyncScrollOffHint')),
+        ),
+      )
+    }
+
     function SettingsPanel() {
       return h('div', { style: { maxWidth: '560px' }, 'data-dsh-plugin': 'dsh-paper-reader', 'data-dsh-surface': 'settings-modal' },
         h(EndpointCard, {
@@ -1433,6 +1502,7 @@ window.__ModuleLoader__.load({
           baseUrlPlaceholder: 'https://api.deepseek.com/v1', modelPlaceholder: 'deepseek-chat', keyPlaceholder: 'sk-...',
         }),
         h(MineruCard, null),
+        h(SyncScrollCard, null),
       )
     }
 
diff --git a/package.json b/package.json
index 3db6823..6c59331 100644
--- a/package.json
+++ b/package.json
@@ -1,6 +1,6 @@
 {
   "name": "@ggboy123/dsh-paper-reader",
-  "version": "1.4.1",
+  "version": "1.5.0",
   "description": "DeepSeek Harness 插件：论文伴读工作台 — PDF 转录 / 检索 / 原生对话伴读 + 内置阅读器页面。",
   "license": "MIT",
   "type": "module",
diff --git a/reader/index.html b/reader/index.html
index f97fbba..5be9db9 100644
--- a/reader/index.html
+++ b/reader/index.html
@@ -8,6 +8,11 @@
      不用 <script type="module">：module 是 defer 语义（整页解析完 + 458KB 拉取编译完才执行），
      而底部经典脚本在解析期就开跑 bootstrap()，库里有论文时先到 loadPdf，此刻 window.pdfjsLib
      还没就绪 → "pdfjsLib is not defined"。改为经典脚本里动态 import()（见 ensurePdfjs），顺序有保证。 -->
+<!-- KaTeX 0.16.22 本地 vendor（数学渲染；论文伴读是**离线场景**，绝不引 CDN）。
+     经典脚本：页面解析期同步设置 window.katex；缺失时渲染路径会**降级**为原始 LaTeX（见 trRenderBody）。
+     体积与来源见 reader/vendor/katex.NOTICE.md。 -->
+<link rel="stylesheet" href="/paper-reader/vendor/katex.min.css">
+<script src="/paper-reader/vendor/katex.min.js"></script>
 <style>
   :root {
     --bg: #f6f7f9; --panel: #ffffff; --border: #e2e5ea; --text: #24292f;
@@ -48,12 +53,22 @@
   @media (max-width: 560px) { #ver { display: none; } }
 
   /* ---------- PDF 区 ---------- */
+  /* #split-wrap 是分屏（模式 B）的两列行容器：非分屏时只有原文列，行为与改造前一致。
+     #pdf-pane 从 #main 的直接子节点变成它的子节点——#main 的 flex 语义不变。 */
   #main { display: flex; flex: 1; min-height: 0; position: relative; } /* relative：公式面板绝对定位的锚 */
-  #pdf-pane { flex: 1; overflow: auto; padding: 16px; }
+  #split-wrap { display: flex; flex-direction: row; gap: 8px; flex: 1; min-width: 0; }
+  #pdf-pane { flex: 1 1 0; min-width: 0; overflow: auto; padding: 16px; }
+  /* 中文列（仅分屏出现）：与原文列同权重、各自滚动 */
+  #pdf-pane-zh { flex: 1 1 0; min-width: 0; overflow: auto; padding: 16px; display: none; }
+  #split-wrap.on > #pdf-pane-zh { display: block; }
+  .pane-label { display: none; position: sticky; top: -16px; z-index: 3; background: var(--bg); color: var(--text-2);
+    font-size: 12px; font-weight: 600; padding: 2px 0 6px; }
+  #split-wrap.on .pane-label { display: block; }
   /* safe center：页宽超过视口时退回左对齐——普通 center 会让左右同时溢出且左侧滚不到 */
   #pdf-pages { display: flex; flex-direction: column; align-items: safe center; gap: 14px; }
+  #pdf-pages-zh { display: flex; flex-direction: column; align-items: safe center; gap: 14px; }
   /* 翻页模式：单页垂直居中（safe center 同理，放大后顶部仍可滚到） */
-  #pdf-pages.paged { min-height: 100%; justify-content: safe center; gap: 0; }
+  #pdf-pages.paged, #pdf-pages-zh.paged { min-height: 100%; justify-content: safe center; gap: 0; }
 
   /* ---------- 翻页控件 ---------- */
   #pager { display: flex; align-items: center; gap: 4px; flex: none; }
@@ -127,6 +142,25 @@
   #ask-send { background: var(--accent); color: #fff; border: none; border-radius: 6px; padding: 5px 14px; cursor: pointer; }
   #ask-send:disabled { opacity: .5; cursor: default; }
   #ask-cancel { background: none; border: none; color: var(--text-2); cursor: pointer; }
+  /* 「译」动作按钮（加法：只在原文视图的纯文字选区出现，见 showAskPop） */
+  #ask-translate { background: none; border: 1px solid var(--border); border-radius: 6px; color: var(--accent); cursor: pointer; }
+
+  /* ---------- 划词译文气泡 ----------
+     用户明确要求：**只显示译文**，不做「插入会话」「复制」按钮 ⇒ 气泡内部零 button 元素。
+     提示（诚实降级文案）走独立的 #tr-note，绝不混进 #tr-body。 */
+  #tr-pop { position: fixed; z-index: 50; display: none; background: var(--panel); border: 1px solid var(--border);
+    border-radius: 10px; box-shadow: 0 6px 24px rgba(0,0,0,.16); padding: 10px;
+    width: min(360px, calc(100vw - 16px)); max-height: 45vh; overflow: auto; }
+  #tr-status { font-size: 12px; color: var(--text-2); }
+  #tr-status:empty { display: none; }
+  #tr-body { font-size: 13px; white-space: pre-wrap; word-break: break-word; }
+  #tr-note { font-size: 12px; color: var(--text-2); margin-top: 6px; line-height: 1.5; }
+  #tr-note:empty { display: none; }
+  /* 公式段：KaTeX 渲染进我们新建的元素（.tr-math / .tr-math-block）；渲染失败时该段落回原始 LaTeX
+     文本并加 .tr-math-fallback（可读可复制，绝不留白）。 */
+  #tr-body .tr-math-block { margin: 6px 0; overflow-x: auto; }
+  #tr-body .tr-math-block .katex-display { margin: 0; }
+  #tr-body .tr-math-fallback { font-family: ui-monospace, SFMono-Regular, Menlo, Consolas, monospace; font-size: 12px; color: var(--text-2); word-break: break-all; }
 
   /* ---------- 翻译端点设置浮层 ---------- */
   /* 阅读器在窄 iframe 里，宽度要能收缩 */
@@ -151,6 +185,12 @@
   <span id="status">论文伴读</span>
   <button id="pdf-path" style="display:none" title="点击复制文件路径"></button>
   <button id="zh-toggle" class="tbtn" title="切换中文译文（没有译文时可生成）" style="display:none" data-icon="translate"></button>
+  <button id="dual-toggle" class="tbtn" title="用 babeldoc 的中英对照 PDF（模式 A）" style="display:none" data-icon="columns">对照</button>
+  <button id="split-toggle" class="tbtn" title="原文与中文版并排同步滚动（模式 B）" style="display:none" data-icon="split">分屏</button>
+  <!-- 「同步滚动」开关（模式 B 的全局偏好）：分屏控件旁，只在分屏下可见（模式 A/原文/译文都没有两个滚动条）。
+       状态换图标（sync / syncOff，与 mode-toggle 的 paged/scroll 同法）+ title 里 zh/en 说明状态；
+       与设置面板里的同一项共用 dpr.syncScroll 键、互相同步。 -->
+  <button id="sync-toggle" class="tbtn" title="同步滚动 / Sync scroll：开（两列一起滚，点击关闭）" style="display:none" data-icon="sync"></button>
   <button id="zh-regen" class="tbtn" title="重新翻译：删除现有译文，用当前端点重跑（换模型后用）" style="display:none" data-icon="regen"></button>
   <button id="dl-btn" class="tbtn" title="下载 PDF" style="display:none" data-icon="download"></button>
   <span class="spacer"></span>
@@ -171,9 +211,16 @@
 </div>
 
 <div id="main">
-  <div id="pdf-pane">
-    <div id="pdf-pages"></div>
-    <div id="empty" style="display:none"></div>
+  <div id="split-wrap">
+    <div id="pdf-pane">
+      <div id="pane-label" class="pane-label">原文</div>
+      <div id="pdf-pages"></div>
+      <div id="empty" style="display:none"></div>
+    </div>
+    <div id="pdf-pane-zh">
+      <div id="pane-label-zh" class="pane-label">中文</div>
+      <div id="pdf-pages-zh"></div>
+    </div>
   </div>
   <div id="eq-panel">
     <h3>公式</h3>
@@ -187,11 +234,19 @@ <h3>公式</h3>
   <textarea id="ask-input" rows="2" placeholder="围绕选中内容提问…"></textarea>
   <div id="ask-actions">
     <button id="ask-copy" style="display:none">复制 LaTeX</button>
+    <button id="ask-translate" style="display:none" title="翻译选中内容（含公式时用 MinerU 的 LaTeX 还原）">译</button>
     <button id="ask-cancel">取消</button>
     <button id="ask-send">提问</button>
   </div>
 </div>
 
+<!-- 划词译文气泡：只有译文 + 状态行 + 一行诚实提示，**零按钮**（用户明确不要插入会话/复制） -->
+<div id="tr-pop">
+  <div id="tr-status"></div>
+  <div id="tr-body"></div>
+  <div id="tr-note"></div>
+</div>
+
 <div id="cfg-pop">
   <h3>翻译端点</h3>
   <div id="cfg-hint">选预设供应商，或选「自定义」填任意 OpenAI 兼容端点（通义 / 本地 vLLM 等）。保存前会先测试连接。</div>
@@ -232,6 +287,10 @@ <h3>翻译端点</h3>
   minus: '<path d="M5 12h14"/>',
   plus: '<path d="M5 12h14"/><path d="M12 5v14"/>',
   sigma: '<path d="M18 7V5H6l6 7-6 7h12v-2"/>',
+  columns: '<rect width="18" height="18" x="3" y="3" rx="2"/><path d="M12 3v18"/>',
+  split: '<rect width="8" height="18" x="3" y="3" rx="2"/><rect width="8" height="18" x="13" y="3" rx="2"/>',
+  sync: '<path d="m17 2 4 4-4 4"/><path d="M3 11v-1a4 4 0 0 1 4-4h14"/><path d="m7 22-4-4 4-4"/><path d="M21 13v1a4 4 0 0 1-4 4H3"/>',
+  syncOff: '<path d="m18.84 12.25 1.72-1.71h-.02a5.004 5.004 0 0 0-.12-7.07 5.006 5.006 0 0 0-6.95 0l-1.72 1.71"/><path d="m5.17 11.75-1.71 1.71a5.004 5.004 0 0 0 .12 7.07 5.006 5.006 0 0 0 6.95 0l1.71-1.71"/><line x1="8" x2="8" y1="2" y2="5"/><line x1="2" x2="5" y1="8" y2="8"/><line x1="16" x2="16" y1="19" y2="22"/><line x1="19" x2="22" y1="16" y2="16"/>',
   spin: '<path d="M21 12a9 9 0 1 1-6.219-8.56"/>',
 };
 const iconHtml = (name) => `<svg class="ic${name === 'spin' ? ' spin' : ''}" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2" stroke-linecap="round" stroke-linejoin="round" aria-hidden="true">${ICONS[name]}</svg>`;
@@ -244,6 +303,9 @@ <h3>翻译端点</h3>
     const err = new Error(body.error || body.reason || ('HTTP ' + r.status));
     err.code = body.code;   // 机器可读码（如 no-endpoint）——让调用方靠它分支，别去匹配中文文案
     err.status = r.status;
+    // 划词翻译的 502 带上游状态码：客户端据此出 §3.7② 的分档文案（拒绝/限流/端点错误），
+    // 而不是去 match 服务端的自由文案。
+    err.upstreamStatus = body.upstreamStatus;
     throw err;
   }
   return r.json();
@@ -264,7 +326,11 @@ <h3>翻译端点</h3>
 let current = null;        // { topic, name }
 let zhState = { zh: false, dual: false, busy: false };
 let statusMeta = ''; // openPaper 的「name · N 页」基线，翻译阶段标签褪去后恢复它
-let zhVariant = null;      // null=原文 'dual'=中英对照 'zh'=纯中文
+let zhVariant = null;      // null=原文 'dual'=中英对照 'zh'=纯中文（**分屏 split 也是 null**，见 C17）
+// 视图模式：四个控件（中/对照/分屏）挂在同一个状态上，互斥（§4.3）。
+// 'split'（模式 B）刻意让 zhVariant 保持 null —— 这样 eqHotEnabled()/公式面板文案/fitMode
+// 等既有分支继续按「原文」工作，零改动。
+let viewMode = 'orig';     // 'orig' | 'zh' | 'dual' | 'split'
 // 每篇论文记住上次用的语言版本：伴读会话的跳转链接原地跳页不重载，
 // 加上这里的恢复，「中文界面跳中文」在同篇跳转/重开/跨论文三条路径上都成立
 const variantKey = (topic, name) => `dpr.variant.${topic}/${name}`;
@@ -283,6 +349,10 @@ <h3>翻译端点</h3>
 async function openPaper(topic, name, opts = {}) {
   if (!name) return;
   current = { topic, name };
+  // R-01/N-01：换文献的在飞译文必须**立刻**失效——必须放在本函数第一处 await 之前。
+  // 原来它在三次 await（`/api/paper`、`refreshZhState`、`loadFormulas`）之后，落在那几个窗口里
+  // 到达的旧响应仍会点亮气泡（t8 复审 N-01：P-A3 实测 seq 2→3 时气泡已显示上一篇译文）。
+  invalidateTranslate();
   localStorage.setItem('dpr.last', JSON.stringify(current));
   curPage = opts.page || 1; // 换论文从第一页（或跳转目标页）开始；变体切换/重译不走这里，页码保持
   $('status').textContent = '加载 PDF…';
@@ -298,17 +368,28 @@ <h3>翻译端点</h3>
   pathBtn.title = (meta.pdfPath || '') + '（点击复制）';
   pathBtn.style.display = meta.pdfPath ? '' : 'none';
   await refreshZhState();
-  // 恢复该论文上次的语言版本（译文已不存在时回落原文）
+  // 恢复该论文上次的视图模式（持久化复用同一个键，取值域扩到 'split'；见 §4.3）
   const saved = localStorage.getItem(variantKey(topic, name));
-  zhVariant = (saved === 'zh' && zhState.zh) || (saved === 'dual' && zhState.dual) ? saved : null;
+  viewMode = viewModeFromSaved(saved, zhState);
+  if (saved && viewMode === 'orig') localStorage.setItem(variantKey(topic, name), ''); // 非空但不可用 → 回写空（防脏值）
+  zhVariant = viewMode === 'zh' ? 'zh' : viewMode === 'dual' ? 'dual' : null; // split → null
   $('zh-toggle').classList.toggle('active', zhVariant !== null);
-  if (zhVariant) { fitMode = true; fitBtn.classList.add('active'); } // 译文版页宽不同，强制适宽
+  // 译文版页宽与原文不同（对照双栏≈2×），分屏每列只有一半宽 ⇒ 都先进适宽
+  if (zhVariant || viewMode === 'split') { fitMode = true; fitBtn.classList.add('active'); }
   // 公式索引（MinerU content_list）：**必须在 loadPdf 之前到货**——热区是在 paintPage 里
   // 按 eqIndex 铺的，先渲染会漏画/残留上一篇的矩形；又必须排在 zhVariant 定稿之后——
   // eqHotEnabled()/renderEqPanel() 都按 zhVariant 决定「译文视图关热区」。失败不影响打开文献。
   await loadFormulas();
   updateDlBtn();
-  await loadPdf(pdfUrl(zhVariant));
+  updateViewButtons();
+  if (viewMode === 'split') {
+    await openSplit(); // 内部自己拉原文 + -zh.pdf 两个文档
+  } else {
+    // R-02：原地换文献时**无条件**退掉分屏（幂等）——否则新论文有 -zh.pdf、而持久化视图又不是
+    // split 时，refreshZhState 的回落守卫不触发，中文列会留着**上一篇**的 PDF（pdfDocZh 也不释放）。
+    teardownSplit();
+    await loadPdf(pdfUrl(zhVariant));
+  }
   if (opts.page) jumpTo(opts.page, opts.q); // 不 await：跳转内部自带「等页面渲出来」轮询
 }
 
@@ -357,25 +438,107 @@ <h3>翻译端点</h3>
   const canRegen = (zhState.zh || zhState.dual) && !zhState.busy;
   regen.style.display = canRegen ? '' : 'none';
   if (!canRegen) disarmRegen();
+  // 分屏激活中 -zh.pdf 没了（重翻/外部删除）→ 自动回落原文 + toast + 把持久化写回 ''（§4.2/B8）
+  if (viewMode === 'split' && !zhState.zh) {
+    toast('中文版不存在，已退回原文', 4000);
+    await setViewMode('orig');
+    return;
+  }
+  updateViewButtons();
+}
+
+/** 顶栏三个视图控件的状态机（§4.3）：文案/active/disabled/title 全在这一处决定。 */
+function updateViewButtons() {
+  const zt = $('zh-toggle'), dt = $('dual-toggle'), st = $('split-toggle');
+  const hasZh = zhState.zh, hasDual = zhState.dual, hasAny = hasZh || hasDual;
+  const splitOn = viewMode === 'split';
+  // 「中」的语义**不变**：原文 ↔ (有 zh ? 'zh' : 'dual')；分屏时加闸（避免在 zhVariant===null
+  // 的误解下误开生成流程），其余情况与改造前逐字一致。
+  zt.disabled = splitOn || zhState.busy;
+  zt.title = splitOn ? '分屏对照中：先关闭分屏'
+    : zhState.busy ? (zhState.phase || `翻译进行中${zhState.model ? `（${zhState.model}）` : ''}…`)
+    : hasAny ? '切换中文译文'
+    : '还没有中文版，点击生成（babeldoc，需要几分钟）';
+  zt.classList.toggle('active', zhVariant !== null);
+
+  dt.style.display = '';   // D1（队长裁定）：按钮恒可见，无产物时 disabled + title 说明原因，
+                           // 把死控件变成解释（与 §6 B1 字面一致，也与 zhonly/dualonly 两态一致）
+  dt.classList.toggle('active', viewMode === 'dual');
+  dt.disabled = zhState.busy || !hasDual;
+  dt.title = zhState.busy ? (zhState.phase || '翻译进行中…')
+    : !hasDual ? '还没有中英对照版，先用「中」生成（babeldoc，需要几分钟）'
+    : viewMode === 'dual' ? '当前：中英对照（模式 A），点击回到原文'
+    : '用 babeldoc 的中英对照 PDF（模式 A）';
+
+  st.style.display = '';   // D1：同上
+  st.classList.toggle('active', splitOn);
+  st.disabled = zhState.busy || !hasZh;
+  st.title = zhState.busy ? (zhState.phase || '翻译进行中…')
+    : !hasZh ? (hasDual ? '需先生成中文版（模式 B 用 -zh.pdf 与原文并排）' : '还没有中文版，先用「中」生成（babeldoc，需要几分钟）')
+    : splitOn ? '当前：分屏对照（模式 B），点击回到原文'
+    : '原文与中文版并排同步滚动（模式 B）';
+
+  // 「同步滚动」开关：与三个视图控件同一个状态机（一处决定所有按钮的可见性/文案/态）；
+  // 仅分屏下可见 —— 模式 A/原文/译文只有一个滚动条，开关无意义
+  updateSyncToggle();
 }
 
 $('zh-toggle').onclick = async () => {
-  if (!current || zhState.busy) return;
+  if (!current || zhState.busy || viewMode === 'split') return;
   if (zhState.dual || zhState.zh) {
-    // 两态切换：原文 ↔ 纯中文；只存在对照版时退到对照
-    zhVariant = zhVariant === null ? (zhState.zh ? 'zh' : 'dual') : null;
-    localStorage.setItem(variantKey(current.topic, current.name), zhVariant ?? '');
-    $('zh-toggle').classList.toggle('active', zhVariant !== null);
-    updateDlBtn();
-    // 切换变体后强制适宽：译文版页宽与原文不同（对照双栏≈2×），不重算会溢出裁切
-    fitMode = true; fitBtn.classList.add('active');
-    renderEqPanel(); // 译文视图要给出「没有位置信息」的说明（热区同时被 eqHotEnabled 关掉）
-    await loadPdf(pdfUrl(zhVariant));
+    // 两态切换：原文 ↔ 纯中文；只存在对照版时退到对照（既有语义一字不动）
+    await setViewMode(zhVariant === null ? (zhState.zh ? 'zh' : 'dual') : 'orig');
     return;
   }
   await startGenerate(false);
 };
 
+/* ================= 视图模式（模式 A 对照 / 模式 B 分屏）=================
+   三个控件共用 viewMode；进入任一非 orig 模式都先退出另一个（互斥）。 */
+
+/** 持久化复用既有键：lib/client.js 的改名搬家只搬 `dpr.variant.` 前缀，新增键不会被迁移（C19）。 */
+function persistViewMode() {
+  localStorage.setItem(variantKey(current.topic, current.name), viewMode === 'orig' ? '' : viewMode);
+}
+
+/** 读回持久化的视图模式（§4.3 的取值表）：译文/分屏不存在时回落原文，非空不可用的值由调用方回写空。 */
+function viewModeFromSaved(saved, st) {
+  if (saved === 'zh' && st.zh) return 'zh';
+  if (saved === 'dual' && st.dual) return 'dual';
+  if (saved === 'split' && st.zh) return 'split';   // 分屏需要 -zh.pdf
+  return 'orig';
+}
+
+/** 视图模式的状态机（守卫 → 赋值 → 持久化 → 三个按钮/下载按钮/公式面板）。
+ *  返回 false = 守卫拦下（状态未变）。渲染留给 setViewMode，便于单测状态机（B11/B12/R4）。 */
+function applyViewMode(mode) {
+  if (!current) return false;
+  if (mode === 'dual' && !zhState.dual) return false;   // 没有 -dual.pdf，不进（按钮已 disabled）
+  if (mode === 'split' && !zhState.zh) return false;    // 没有 -zh.pdf，不进
+  if (mode === 'split' && window.innerWidth < SPLIT_MIN_WIDTH) {
+    toast('面板太窄，请把阅读器拉宽后再用分屏对照', 4000);
+    return false;
+  }
+  viewMode = mode;
+  zhVariant = mode === 'zh' ? 'zh' : mode === 'dual' ? 'dual' : null; // split → null（C17）
+  persistViewMode();
+  // 切换变体后强制适宽：译文版页宽与原文不同（对照双栏≈2×、分屏每列半宽），不重算会溢出裁切
+  fitMode = true; fitBtn.classList.add('active');
+  updateViewButtons();
+  updateDlBtn();
+  renderEqPanel(); // 译文视图要给出「没有位置信息」的说明（热区同时被 eqHotEnabled 关掉）
+  return true;
+}
+
+async function setViewMode(mode) {
+  if (!applyViewMode(mode)) return;
+  if (mode === 'split') { await openSplit(); return; }
+  teardownSplit();
+  await loadPdf(pdfUrl(zhVariant));
+}
+$('dual-toggle').onclick = () => setViewMode(viewMode === 'dual' ? 'orig' : 'dual');
+$('split-toggle').onclick = () => setViewMode(viewMode === 'split' ? 'orig' : 'split');
+
 // 生成/重翻共用：force=true 时服务端先删旧译文再启动；成功后轮询到完成
 async function startGenerate(force) {
   try {
@@ -400,8 +563,9 @@ <h3>翻译端点</h3>
       clearInterval(timer);
       if (zhState.dual || zhState.zh) {
         toast('中文版已生成');
-        // 重翻完成时用户可能正停在译文视图：原地刷新同一变体，而不是来回切换
-        if (zhVariant) await loadPdf(pdfUrl(zhVariant));
+        // 重翻完成时用户可能正停在译文视图/分屏：原地刷新，而不是来回切换
+        if (viewMode === 'split') await renderSplit();
+        else if (zhVariant) await loadPdf(pdfUrl(zhVariant));
         else $('zh-toggle').click();
       }
       else toast('生成失败：' + (zhState.error || '未知原因'), 8000);
@@ -463,7 +627,8 @@ <h3>翻译端点</h3>
 
 // 保存成功后是否自动接着生成：点「中译」/「重翻」发现没配 → 弹本表单 → 填完直接开跑
 let cfgRetryGenerate = false;
-let cfgRetryForce = false;   // 待重试的是不是「重翻」（重翻进来时旧译文还在，zh-toggle 点击语义不对，必须带 force）
+let cfgRetryForce = false;   // 待重试的是不是「重翻」（regen 图标进来时旧译文还在，zh-toggle 点击语义不对，必须带 force）
+let cfgRetryTranslate = false; // 待重试的是不是「划词翻译」（点「译」发现没配端点 → 填完自动重试这次翻译）
 
 async function openCfgPop(retryGenerate) {
   cfgRetryGenerate = Boolean(retryGenerate);
@@ -495,14 +660,14 @@ <h3>翻译端点</h3>
   pop.style.top = Math.max(8, (window.innerHeight - pop.offsetHeight) / 3) + 'px';
   $('cfg-key').focus();
 }
-function closeCfgPop() { $('cfg-pop').style.display = 'none'; cfgRetryGenerate = false; cfgRetryForce = false; }
+function closeCfgPop() { $('cfg-pop').style.display = 'none'; cfgRetryGenerate = false; cfgRetryForce = false; cfgRetryTranslate = false; }
 
 $('cfg-open').onclick = () => openCfgPop(false);
 $('cfg-cancel').onclick = closeCfgPop;
 
 $('cfg-save').onclick = async () => {
-  // retry/force 先捞出来：closeCfgPop 会把这两个待确认态清零
-  const btn = $('cfg-save'), label = btn.textContent, retry = cfgRetryGenerate, force = cfgRetryForce;
+  // retry/force/translate 先捞出来：closeCfgPop 会把这三个待确认态清零
+  const btn = $('cfg-save'), label = btn.textContent, retry = cfgRetryGenerate, force = cfgRetryForce, retryTr = cfgRetryTranslate;
   btn.disabled = true; btn.textContent = '测试中…';
   try {
     // 服务端先打一发极小的 chat/completions 验证 url/key/model，通过才落盘
@@ -523,7 +688,8 @@ <h3>翻译端点</h3>
   }
   closeCfgPop();
   await refreshZhState();
-  if (retry) startGenerate(force);  // 沿用触发来源的语义：「中译」=生成，「重翻」=重翻
+  if (retry) startGenerate(force);  // 沿用触发来源的语义：zh-toggle=生成，regen=重翻
+  else if (retryTr) translateSelection(); // 划词翻译发现没配端点 → 填完自动重试这一次翻译（§3.7①）
   else toast('翻译端点已保存');
 };
 
@@ -565,22 +731,27 @@ <h3>翻译端点</h3>
   });
 })();
 
-async function loadPdf(url) {
+async function loadPdf(url, opts = {}) {
   await ensurePdfjs(); // 就绪前禁止触 pdfjsLib（defer 竞态，见文件头注释）
   pdfDoc = await pdfjsLib.getDocument({ url }).promise; // v6 起不接受字符串参数，必须传对象
   $('empty').style.display = 'none';
   // 翻页控件与模式切换按钮：文档就绪后才出现
   $('pager').style.display = '';
   $('mode-toggle').style.display = '';
+  // 分屏（模式 B）自己安排两列的渲染与适宽：这里只把原文文档装上，不触发单列渲染
+  if (opts.deferRender) return;
   if (fitMode) { fitToWidth(); return; } // fitToWidth 内部 setZoom → rerender
   await rerender();
 }
 
-/** 构建单页 DOM 骨架（.page + canvas + textLayer），位图与文本由 paintPage 异步填充。 */
-function makePageNode(i, viewport) {
+/** 构建单页 DOM 骨架（.page + canvas + textLayer），位图与文本由 paintPage 异步填充。
+ *  `doc` = 'orig' | 'zh'：**无条件**写在每个页节点上（分屏时两个文档的页号相同，热区几何
+ *  与选区归属都靠它判别；只有分屏才写的话普通模式的选择器会取到 null）。 */
+function makePageNode(i, viewport, doc = 'orig') {
   const div = document.createElement('div');
   div.className = 'page';
   div.dataset.page = i;
+  div.dataset.doc = doc;
   div.style.width = viewport.width + 'px';
 
   const canvas = document.createElement('canvas');
@@ -625,8 +796,10 @@ <h3>翻译端点</h3>
   paintEqLayer(div, viewport, +div.dataset.page);
 }
 
-/** 当前模式的全量重渲入口：缩放/DPR/换文档/换变体统一走这里。 */
+/** 当前模式的全量重渲入口：缩放/DPR/换文档/换变体统一走这里。
+ *  分屏（模式 B）是第三套布局，转到 renderSplit()；renderPaged/renderAllPages 的既有语义**不变**。 */
 function rerender() {
+  if (viewMode === 'split') return renderSplit();
   return pageMode === 'paged' ? renderPaged() : renderAllPages();
 }
 
@@ -709,9 +882,18 @@ <h3>翻译端点</h3>
 const fitBtn = $('zoom-fit');
 fitBtn.classList.add('active');
 function exitFitMode() { fitMode = false; fitBtn.classList.remove('active'); }
+/** 适宽的可用宽度（分屏时按**较窄的那一列**算，保证两列页高一致）。每列 padding 16px×2。 */
+function fitPaneWidth() {
+  if (viewMode === 'split') {
+    const avail = [$('pdf-pane').clientWidth - 32, $('pdf-pane-zh').clientWidth - 32].filter((w) => w > 0)
+    if (!avail.length) return 0
+    return Math.min(...avail)
+  }
+  return $('pdf-pane').clientWidth - 32
+}
 function fitToWidth() {
   if (!pdfDoc) return // resize 可能先于首次 loadPdf 触发（布局换位/条带注入会改容器尺寸）
-  const paneWidth = $('pdf-pane').clientWidth - 32
+  const paneWidth = fitPaneWidth()
   if (paneWidth <= 0) return // 隐藏期间尺寸为 0，算出的缩放无意义
   pdfDoc.getPage(1).then((p) => setZoom(paneWidth / p.getViewport({ scale: 1 }).width))
 }
@@ -719,13 +901,25 @@ <h3>翻译端点</h3>
 $('zoom-out').onclick = () => { exitFitMode(); setZoom(zoomScale - 0.25); };
 fitBtn.onclick = () => { if (!pdfDoc) return; fitMode = true; fitBtn.classList.add('active'); fitBtn.blur(); fitToWidth(); };
 window.addEventListener('resize', () => {
+  if (viewMode === 'split' && window.innerWidth < SPLIT_MIN_WIDTH) {
+    // 分屏被缩到硬闸门以下：回落原文 + 同一提示（§4.2）
+    toast('面板太窄，请把阅读器拉宽后再用分屏对照', 4000);
+    setViewMode('orig');
+    return;
+  }
   if (fitMode) fitToWidth(); // setZoom → rerender，顺带消化 pendingRerender
   else if (pendingRerender && pdfDoc) { pendingRerender = false; rerender(); } // 隐藏期间欠下的重渲，恢复尺寸后补画
 });
 
+/** 原文列的页节点：分屏时中文列有**同样的 page 号**，不加限定会取到中文列（C18/R7）。
+ *  统一收敛到 `#pdf-pages` 之下——四个引文高亮/跳转入口共用。 */
+function origPageNode(n) {
+  return document.querySelector(`#pdf-pages .page[data-page="${n}"]`);
+}
+
 /* ================= 翻页模式：页码控件 + 模式切换 + 键盘 ================= */
 function flashPage() {
-  const div = document.querySelector(`.page[data-page="${curPage}"]`);
+  const div = origPageNode(curPage);
   if (!div) return;
   div.classList.add('flash');
   setTimeout(() => div.classList.remove('flash'), 1600);
@@ -748,7 +942,7 @@ <h3>翻译端点</h3>
   if (pageMode === 'paged') {
     if (p === curPage) { flashPage(); return; }
     curPage = p;
-    await renderPaged();
+    await rerender();
     flashPage();
   } else {
     curPage = p;
@@ -789,10 +983,10 @@ <h3>翻译端点</h3>
   localStorage.setItem('dpr.pageMode', pageMode);
   updateModeToggle();
   if (pageMode === 'paged') {
-    await renderPaged();
+    await rerender();          // 分屏时转 renderSplit（两列同渲 curPage）
     flashPage();
   } else {
-    await renderAllPages();
+    await rerender();          // 非分屏时等价于 renderAllPages
     jumpToPage(curPage);
   }
 };
@@ -811,7 +1005,7 @@ <h3>翻译端点</h3>
 
 function jumpToPage(n) {
   if (pageMode === 'paged') { goPage(n); return; }
-  const div = document.querySelector(`.page[data-page="${n}"]`);
+  const div = origPageNode(n);   // 引文跳转只作用于原文列（分屏时中文列不得被滚到）
   if (!div) return;
   div.scrollIntoView({ behavior: 'smooth', block: 'start' });
   div.classList.add('flash');
@@ -829,7 +1023,7 @@ <h3>翻译端点</h3>
 document.addEventListener('mousedown', clearHighlights);
 
 function highlightSnippet(page, q) {
-  const spans = [...(document.querySelector(`.page[data-page="${page}"]`)?.querySelectorAll('.textLayer span:not(.markedContent)') ?? [])];
+  const spans = [...(origPageNode(page)?.querySelectorAll('.textLayer span:not(.markedContent)') ?? [])];
   if (!spans.length || !q) return false;
   let hay = '';
   const startOf = [];
@@ -862,12 +1056,12 @@ <h3>翻译端点</h3>
   if (pageMode === 'paged') {
     if (!pdfDoc) return;
     const p = Math.min(p0, pdfDoc.numPages);
-    if (p !== curPage) { curPage = p; await renderPaged(); }
+    if (p !== curPage) { curPage = p; await rerender(); }
     if (!(q && highlightSnippet(p, q))) flashPage();
     return;
   }
   for (let i = 0; i < 100; i++) {
-    if (pdfDoc && document.querySelector(`.page[data-page="${Math.min(p0, pdfDoc.numPages)}"]`)) {
+    if (pdfDoc && origPageNode(Math.min(p0, pdfDoc.numPages))) {
       const p = Math.min(p0, pdfDoc.numPages);
       if (!(q && highlightSnippet(p, q))) jumpToPage(p);
       return;
@@ -962,11 +1156,17 @@ <h3>翻译端点</h3>
   };
 }
 
-/** 为已渲染的一页铺热区层（只画描边，不接事件）。 */
+/** 为已渲染的一页铺热区层（只画描边，不接事件）。
+ *  **只在原文列铺**：分屏（模式 B）时中文列的页号与原文列相同，而 EQ_BY_PAGE 是全局的，
+ *  照铺会让中文列的点击命中原文几何（C18/R7）。文档作用域从页节点自身读——唯一铺层点的
+ *  调用签名被既有断言钉死为 `paintEqLayer(div, viewport, +div.dataset.page)`
+ *  （test/merge-verify-t3.test.mjs 的 checkSolePaintPoint），不能再加第 4 个参数。 */
 function paintEqLayer(pageDiv, viewport, pageNo) {
   const old = pageDiv.querySelector('.eqLayer');
   if (old) old.remove();
   const items = [];
+  const doc = pageDiv.dataset.doc || 'orig';
+  if (doc !== 'orig') return;   // 中文列：不建层、不写 EQ_BY_PAGE
   if (eqHotEnabled()) {
     const lay = document.createElement('div');
     lay.className = 'eqLayer';
@@ -1003,6 +1203,8 @@ <h3>翻译端点</h3>
   const el = e.target;
   const pageDiv = el && el.closest ? el.closest('.page[data-page]') : null;
   if (!pageDiv) return null;
+  // 中文列（分屏）不得命中：它的页号与原文列相同，几何却属于原文页面（C18/R7）
+  if (pageDiv.dataset.doc && pageDiv.dataset.doc !== 'orig') return null;
   const items = EQ_BY_PAGE.get(+pageDiv.dataset.page);
   if (!items || !items.length) return null;
   const box = pageDiv.getBoundingClientRect();
@@ -1184,6 +1386,17 @@ <h3>翻译端点</h3>
   $('ask-quote').textContent = o.quote.length > 140 ? o.quote.slice(0, 140) + '…' : o.quote;
   $('ask-input').value = '';
   $('ask-copy').style.display = askSelection && askSelection.kind === 'equation' ? 'inline-block' : 'none';
+  // 「译」只在「纯文字选区 + 原文视图 + **原文列** + 长度可翻译」时出现。
+  // 分屏（模式 B）时 zhVariant 刻意保持 null（C17），中文列也满足那个条件 —— 但中文列的字符
+  // 在 collectSelectionChars 里会被整体跳过（几何只对原文页成立）⇒ chunks 为空、只会弹
+  // 「选区已失效」。所以这里按列禁用（R-07：e.target/doc 判别），不给误导性文案。
+  $('ask-translate').style.display =
+    askSelection && askSelection.kind === 'text' && zhVariant === null
+      && (askSelection.doc ?? 'orig') === 'orig'
+      && askSelection.text.length <= MAX_SELECTION_CHARS
+      ? 'inline-block' : 'none';
+  hideTrPop(); // 新选区/新引用出现即收起上一个译文气泡（同一锚点必然重叠）
+  invalidateTranslate(); // R-01：新选区/新引用必须让在飞请求失效，否则旧译文会盖到新锚点上
   askPop.style.display = 'block';
   // 夹在 iframe 视口内（rightbar 窄列里也要能用）
   const popW = 336, popH = 200;
@@ -1213,7 +1426,22 @@ <h3>翻译端点</h3>
     const node = sel.anchorNode && sel.anchorNode.parentElement;
     if (!node || !node.closest('.textLayer')) { askPop.style.display = 'none'; return; }
     const range = sel.getRangeAt(0).getBoundingClientRect();
-    askSelection = { text, page: +((node.closest('.page') || {}).dataset?.page || 0) || null, kind: 'text' };
+    // `doc` = 选区落在哪一列（'orig' | 'zh'）：分屏时中文列也有 .page 与文本层，但它的几何
+    // 对不上原文的 equation 索引，且不该出现「译」（R-07）。无条件写：普通模式恒为 'orig'。
+    const pageEl = node.closest('.page[data-doc]') || node.closest('.page');
+    askSelection = {
+      text,
+      page: +((pageEl || {}).dataset?.page || 0) || null,
+      kind: 'text',
+      doc: (pageEl && pageEl.dataset && pageEl.dataset.doc) || 'orig',
+    };
+    // 选区 Range 必须在**选中时**克隆存下来：用户点「译」时浏览器多半已清掉选区。
+    // 防御：DOM stub / 极端环境下 getRangeAt 可能不返回 Range（没有 cloneRange），此时存 null，
+    // 点「译」时按「页面已重绘，请重新选择」如实提示——绝不静默失败。
+    try {
+      const r0 = sel.getRangeAt(0);
+      if (r0 && typeof r0.cloneRange === 'function') askSelection.range = r0.cloneRange();
+    } catch { /* 选区已失效：保持无 range */ }
     showAskPop({ quote: text, x: e.clientX, y: range.bottom + 8 });
   }, 10);
 });
@@ -1272,6 +1500,752 @@ <h3>翻译端点</h3>
 };
 $('ask-input').addEventListener('keydown', (e) => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); $('ask-send').click(); } });
 
+/* =====================================================================================
+   划词翻译（公式保留）—— 契约 docs/selection-translate-requirements.md §3.1–§3.3
+   · 触发：既有 #ask-pop 里新增的「译」按钮 → 隐藏 #ask-pop、弹独立译文气泡 #tr-pop
+   · 气泡**只有译文**（#tr-body）+ 状态行 + 一行诚实提示（#tr-note）；内部零 button
+   · 选区切块：display 公式按「字符矩形中心点 ∩ equation 盒」整段丢掉乱码、换成紧凑 LaTeX；
+     行内公式的还原在服务端做（客户端只送 chunk，不送任何矩形/bbox）
+   · 新代码一律放在 $('ask-cancel').onclick **之后**（既有源码切片断言，
+     test/reader-ux-verification.test.mjs VA9）
+   ===================================================================================== */
+const MAX_SELECTION_CHARS = 4000;   // 冻结：选区超长截断并提示
+const MAX_CHUNKS = 200;             // 与服务端同一套上限（§3.2-6）
+const MAX_TOTAL_CHARS = 8000;
+const TR_CLIENT_TIMEOUT_MS = 45000; // 服务端 30s，客户端 45s 兜底（§3.6）
+const trPop = $('tr-pop');
+let trBusy = false;
+let trSeq = 0;                      // 过期保护：换选区/换文献后旧译文不得盖上来（仿 renderToken）
+
+/**
+ * 让**在飞**的划词翻译请求失效（R-01）。调用点：`showAskPop`（新选区/新引用）与 `openPaper`（换文献）。
+ * 只自增 `trSeq` 会让旧请求的 `finally` 因为 `seq !== trSeq` 而不清 `trBusy`（按钮从此永久失效），
+ * 所以这里一并把 busy 复位；旧响应回来时 `seq` 不匹配 ⇒ 直接丢弃，绝不会写到新锚点的气泡上。
+ */
+function invalidateTranslate() {
+  trSeq++;
+  trBusy = false;
+  // 顺手收起气泡并清掉内容：在飞请求回来时会被 seq 拦下，**不会**再写气泡，
+  // 所以留着「翻译中…」或上一篇的译文都是误导（N-01 的窗口里尤其明显）。
+  hideTrPop();
+  $('tr-status').textContent = '';
+  $('tr-body').textContent = '';
+  $('tr-note').textContent = '';
+}
+
+function hideTrPop() { trPop.style.display = 'none'; }
+
+/* ── 译文里的公式渲染（vendored KaTeX，离线）────────────────────────────────────────────
+   译文是**模型输出，当不可信数据**处理，所以这里绝不 innerHTML：
+     · 文本段：一律 textContent；
+     · 数学段：KaTeX 渲染进**我们新建的**元素（trust:false → 不产原始 HTML；strict:'ignore'）；
+     · 渲染失败：该段**降级**为原始 LaTeX 文本（可读可复制），并在 #tr-note 如实提示第几个失败。
+   `splitTranslatedMath` / `trComposeNote` 是纯函数，可在 vm 里单测。 */
+
+/** 「这段 `$…$` 像不像数学」（与 src/translate-selection.ts 的 `isLatexLikeFragment` 同判据 + 两道收窄）。
+ *  过度识别的代价更大：`$5 到 $10`、`$HOME/bin:$PATH` 这类一旦被当公式，正文会被 KaTeX 吃掉。
+ *  规则（自上而下）：
+ *    ① 含 LaTeX 特征（`\` `_` `^` `{` `}` `&`）⇒ 像数学；
+ *    ② 含空白却没有特征 ⇒ 像散文/金额（`$5 up to $10`）⇒ 不是；
+ *    ③ 全大写标识符（`HOME`、`PATH`）⇒ 不是；
+ *    ④ `NAME:…` 形态（命令行/环境变量写法）⇒ 不是；
+ *    ⑤ 其余短符号串（`x`、`QK`、`a/b`）⇒ 是（上限 24 字符，避免把长路径吃掉）。 */
+function looksLikeMath(tex) {
+  const t = String(tex);
+  if (!t.trim()) return false;
+  if (/[\\_^{}&]/.test(t)) return true;
+  if (/\s/.test(t)) return false;
+  if (/^[A-Z][A-Z0-9_]*$/.test(t)) return false;
+  if (/^[A-Za-z0-9_./-]+:/.test(t)) return false;
+  return t.length <= 24;
+}
+
+/** 把译文切成 [{kind:'text'|'math', text, display, delim}]。
+ *  `$$…$$` 独立成行（可跨行）；`$…$` 行内（不跨行，避免把整段散文吞进公式）；`\$` 是字面美元号；
+ *  `\(…\)` 行内、`\[…\]` 独立成行（模型/上游有时给这套定界符，见 pr7 诊断 P2）；
+ *  定界符没有闭合、或 `$…$` 内容不像数学时按普通字符处理（绝不产生"半个公式"，也不吃正文）。 */
+function splitTranslatedMath(input) {
+  const s = String(input ?? '');
+  const out = [];
+  let buf = '';
+  const flush = () => { if (buf) { out.push({ kind: 'text', text: buf }); buf = ''; } };
+  for (let i = 0; i < s.length;) {
+    if (s[i] === '\\' && s[i + 1] === '$') { buf += '$'; i += 2; continue; }
+    // \(…\) 行内 / \[…\] 独立成行：与 $ 一样，必须找到闭合才认（否则按字面字符处理）
+    if (s[i] === '\\' && (s[i + 1] === '(' || s[i + 1] === '[')) {
+      const display = s[i + 1] === '[';
+      const closeSeq = display ? '\\]' : '\\)';
+      let j = i + 2;
+      let close = -1;
+      while (j < s.length) {
+        if (s[j] === '\\') {
+          if (s[j + 1] === (display ? ']' : ')')) { close = j; break; }
+          j += 2; continue;
+        }
+        if (!display && s[j] === '\n') break;   // 行内不跨行（同 $…$ 的口径）
+        j += 1;
+      }
+      const tex = close === -1 ? '' : s.slice(i + 2, close);
+      if (close !== -1 && tex.trim() && looksLikeMath(tex)) {
+        flush();
+        out.push({ kind: 'math', text: tex, display, delim: closeSeq });
+        i = close + 2;
+        continue;
+      }
+      buf += s.slice(i, i + 2); i += 2; continue;   // 不闭合/不像数学 → 原样当文本
+    }
+    if (s[i] !== '$') { buf += s[i]; i += 1; continue; }
+    const display = s[i + 1] === '$';
+    const open = display ? 2 : 1;
+    let j = i + open;
+    let close = -1;
+    while (j < s.length) {
+      if (s[j] === '\\') { j += 2; continue; }
+      if (display ? (s[j] === '$' && s[j + 1] === '$') : (s[j] === '$')) { close = j; break; }
+      if (!display && s[j] === '\n') break;          // 行内公式不跨行
+      j += 1;
+    }
+    if (close === -1) { buf += s.slice(i, i + open); i += open; continue; }
+    const tex = s.slice(i + open, close);
+    if (!tex.trim() || !looksLikeMath(tex)) { buf += s.slice(i, close + open); i = close + open; continue; }
+    flush();
+    out.push({ kind: 'math', text: tex, display, delim: open === 2 ? '$$' : '$' });
+    i = close + open;
+  }
+  flush();
+  return out;
+}
+
+/* 模式解析：MinerU 的**展示公式**常带 `\tag{}`（KaTeX 硬规则：\tag 只允许展示模式），而服务端
+   `assembleSource` 会把展示公式统一包成**行内 `$…$`** ⇒ 按 `display:false` 渲染必失败（pr7 诊断 P1：
+   35/37 真实 equation 命中）。这里先按切分结果探测，失败再按**另一种模式**探测：
+   只有真的行内渲染不了时才升级成展示模式 ⇒ **零误伤**（不会把普通行内公式变成块级）。
+   两种都失败返回 null，交给调用方走降级（原始 LaTeX + #tr-note，绝不留白）。 */
+function resolveMathMode(tex, display) {
+  const k = typeof window !== 'undefined' ? window.katex : null;
+  if (!k || typeof k.renderToString !== 'function') return null;
+  const probe = (d) => {
+    k.renderToString(tex, { displayMode: d, throwOnError: true, trust: false, strict: 'ignore' });
+    return d;
+  };
+  try { return probe(display); } catch { /* 按切分结果渲染不了 → 试另一种模式 */ }
+  try { return probe(!display); } catch { return null; }
+}
+
+/** 把一段 LaTeX 渲染进**我们新建的**元素（KaTeX，vendored 离线）。
+ *  · 先 `renderToString` + `throwOnError:true` 探一次：非法 LaTeX 在这里抛，交给调用方降级
+ *    （既满足契约参数 `throwOnError:false`，又不会把 KaTeX 自己画的红色错误当成功）；
+ *  · 真正渲染用契约参数：`throwOnError:false` / `trust:false` / `strict:'ignore'`。
+ *  **不写 innerHTML**：KaTeX 自己建 DOM 节点，模型输出只作为待转义的 LaTeX 文本传入。 */
+function renderMathSegment(el, tex, display) {
+  const k = typeof window !== 'undefined' ? window.katex : null;
+  if (!k || typeof k.renderToString !== 'function' || typeof k.render !== 'function') throw new Error('katex 不可用');
+  k.renderToString(tex, { displayMode: display, throwOnError: true, trust: false, strict: 'ignore' });
+  k.render(tex, el, { displayMode: display, throwOnError: false, trust: false, strict: 'ignore' });
+}
+
+/** 渲染译文到 #tr-body：文本段 textContent，数学段 KaTeX → 新建元素；渲染失败的段落回原始 LaTeX
+ *  文本（绝不空白）。返回未能渲染的公式序号（1 起，供 #tr-note 提示）。 */
+function trRenderBody(body) {
+  const host = $('tr-body');
+  host.textContent = '';
+  const failed = [];
+  let n = 0;
+  for (const seg of splitTranslatedMath(body)) {
+    if (seg.kind === 'text') {
+      const el = document.createElement('span');
+      el.textContent = seg.text;                       // ← 模型输出的文本：只用 textContent
+      host.appendChild(el);
+      continue;
+    }
+    n += 1;
+    // 先解析该用哪种模式（探测失败会换另一种重试），再决定元素的形态
+    const mode = resolveMathMode(seg.text, seg.display);
+    const block = mode === true;                        // 只有真的按展示模式渲染时才用块级
+    const el = document.createElement(block ? 'div' : 'span');
+    el.className = block ? 'tr-math tr-math-block' : 'tr-math';
+    let ok = mode !== null;
+    if (ok) { try { renderMathSegment(el, seg.text, mode); } catch { ok = false; } }
+    if (!ok) {
+      el.className = 'tr-math tr-math-fallback';
+      const delim = seg.delim ?? (seg.display ? '$$' : '$');
+      el.textContent = delim + seg.text + delim;        // 降级：原始 LaTeX 原样可见、可复制
+      failed.push(n);
+    }
+    host.appendChild(el);
+  }
+  return failed;
+}
+
+/** #tr-note 文案（**仍是纯文本**）：原有提示 + 渲染失败提示，如「第 2、5 个公式未能渲染（已按原样显示 LaTeX）」。 */
+function trComposeNote(note, failed) {
+  const base = String(note ?? '');
+  if (!failed || !failed.length) return base;
+  const which = failed.length === 1 ? `第 ${failed[0]} 个公式` : `第 ${failed.join('、')} 个公式`;
+  const hint = `${which}未能渲染（已按原样显示 LaTeX）`;
+  return base ? `${base} ${hint}` : hint;
+}
+
+/** 展示译文气泡。**绝不 innerHTML 模型输出**：文本段 textContent，数学段交 trRenderBody 渲染进新建元素。
+ *  定位照 openCfgPop：先显示再量尺寸，不写死宽高常量。 */
+function showTrPop(status, body, note) {
+  $('tr-status').textContent = status || '';
+  const failed = trRenderBody(body || '');
+  $('tr-note').textContent = trComposeNote(note, failed);
+  trPop.style.display = 'block';
+  let rect = { left: 16, bottom: 16 };
+  try { if (askSelection && askSelection.range) rect = askSelection.range.getBoundingClientRect(); } catch { /* 选区失效用兜底锚点 */ }
+  trPop.style.left = Math.max(8, Math.min(rect.left, window.innerWidth - trPop.offsetWidth - 8)) + 'px';
+  trPop.style.top = Math.max(8, Math.min(rect.bottom + 8, window.innerHeight - trPop.offsetHeight - 8)) + 'px';
+}
+
+/** 归属判定（§3.3① 冻结规则）：**字符矩形中心点落在 equation 盒内**（不用「有任何交叠」——
+ *  实测 2/18 例会把下一行正文吞进来）；并列取面积最小者（与既有热区点击 hitTestFormula 同规则）。 */
+function formulaBoxByCenter(rect, items) {
+  if (!items || !items.length) return null;
+  const cx = (rect[0] + rect[2]) / 2, cy = (rect[1] + rect[3]) / 2;
+  let best = null;
+  for (const it of items) {
+    if (cx >= it.x0 && cx <= it.x1 && cy >= it.y0 && cy <= it.y1) {
+      if (!best || it.w * it.h < best.w * best.h) best = it;
+    }
+  }
+  return best;
+}
+
+/** 当前页几何（paintEqLayer 写进 EQ_BY_PAGE 的 items）。仅在原文视图 + 有 bbox 时可用。 */
+function eqItemsFor(pageNo) {
+  if (!eqHotEnabled()) return null;
+  return EQ_BY_PAGE.get(pageNo) || null;
+}
+
+/** 字符序列 → chunk 序列（§3.2-6 冻结切法）。
+ *  chars: [{ch, page, rect}]（rect 为页面局部 px；缺失/退化的字符按纯文本处理）
+ *  规则：同页 + 同归属 + 无换行的最大连续段；换行是 text 段的结尾字符；公式段整体丢弃乱码、
+ *  换成紧凑 LaTeX（`$` 定界在服务端加）。 */
+function buildChunks(chars, itemsByPage) {
+  const out = [];
+  let cur = null;
+  const flush = () => { if (cur) out.push(cur); cur = null; };
+  for (const c of chars) {
+    // 命中物是热区几何 {eq, x0, y0, x1, y1, …}（见 eqGeom）；公式本体在 .eq 上
+    const hit = c.rect ? formulaBoxByCenter(c.rect, itemsByPage ? itemsByPage(c.page) : null) : null;
+    const entry = hit ? hit.eq : null;
+    const kind = entry ? 'formula' : 'text';
+    if (c.ch === '\n' && kind === 'text') {
+      if (cur && cur.kind === 'text') { cur.text += '\n'; flush(); }
+      else { flush(); out.push({ page: c.page, kind: 'text', text: '\n' }); }
+      continue;
+    }
+    if (cur && cur.page === c.page && cur.kind === kind && (kind === 'text' || cur.eqId === entry.id)) {
+      if (kind === 'text') cur.text += c.ch;
+      continue; // formula：同一条公式的后续字符直接丢弃（LaTeX 是原子的）
+    }
+    flush();
+    cur = kind === 'formula'
+      ? { page: c.page, kind: 'formula', latex: eqLatex(entry.latex), eqId: entry.id }
+      : { page: c.page, kind: 'text', text: c.ch };
+  }
+  flush();
+  // 规模闸门：段数 ≤200、单段 text ≤4000、总长 ≤8000（超限从尾部截断，并让调用方提示）
+  const capped = [];
+  let total = 0;
+  for (const c of out) {
+    const payload = c.kind === 'text' ? c.text : c.latex;
+    if (capped.length >= MAX_CHUNKS) break;
+    const room = MAX_TOTAL_CHARS - total;
+    if (room <= 0) break;
+    let s = payload;
+    const cap = c.kind === 'text' ? Math.min(MAX_SELECTION_CHARS, room) : room;
+    if (s.length > cap) s = s.slice(0, cap);
+    if (!s) continue;
+    total += s.length;
+    capped.push(c.kind === 'text' ? { page: c.page, kind: 'text', text: s } : { page: c.page, kind: 'formula', latex: s });
+  }
+  return capped;
+}
+
+/** 选区覆盖的文本节点（按文档序）。手写递归而不是 createTreeWalker：
+ *  选区只需要「起点与终点之间的文本节点」，而 TreeWalker 在部分 webview/测试桩里缺实现。 */
+function textNodesUnder(node) {
+  const out = [];
+  const stack = [node];
+  while (stack.length) {
+    const n = stack.pop();
+    if (!n) continue;
+    if (n.nodeType === 3) { out.push(n); continue; }
+    const kids = n.childNodes ? [...n.childNodes] : [];
+    for (let i = kids.length - 1; i >= 0; i--) stack.push(kids[i]);
+  }
+  return out;
+}
+
+/** 选区内每个字符 + 它的页面局部矩形（页面局部 = rect 减 pageDiv 的 bounding rect；
+ *  `.page` 上没有 CSS transform，缩放体现在 viewport 尺寸里 ⇒ 与滚动/翻页/缩放都无关，
+ *  与既有 hitTestFormula 用的是同一套坐标）。 */
+function collectSelectionChars(range) {
+  const root = range.commonAncestorContainer;
+  if (!root) return [];
+  const nodes = textNodesUnder(root).filter((n) => {
+    if (typeof range.intersectsNode === 'function') { try { return range.intersectsNode(n); } catch { return true; } }
+    return n === range.startContainer || n === range.endContainer;
+  });
+  const out = [];
+  for (const node of nodes) {
+    const data = node.data ?? '';
+    let start = 0, end = data.length;
+    if (node === range.startContainer) start = range.startOffset;
+    if (node === range.endContainer) end = range.endOffset;
+    const parent = node.parentElement;
+    const pageDiv = parent && parent.closest ? parent.closest('.page[data-doc]') : null;
+    if (!pageDiv) continue;
+    const doc = pageDiv.dataset.doc || 'orig';
+    if (doc !== 'orig') continue;            // 分屏时中文列不参与公式归属（同一套几何只对原文成立）
+    const pageNo = +pageDiv.dataset.page || 0;
+    const box = pageDiv.getBoundingClientRect();
+    const cr = document.createRange();
+    for (let i = start; i < end; i++) {
+      let rect = null;
+      try {
+        cr.setStart(node, i); cr.setEnd(node, i + 1);
+        const r = cr.getBoundingClientRect();
+        if (r && r.width > 0 && r.height > 0) {
+          rect = [r.left - box.left, r.top - box.top, r.right - box.left, r.bottom - box.top];
+        }
+      } catch { rect = null; }              // 换行伪影/失效 Range：退化成纯文本字符
+      out.push({ ch: data[i], page: pageNo, rect });
+    }
+  }
+  return out;
+}
+
+/** #tr-note 的诚实降级文案（§3.8 文案表，优先级自上而下）。
+ *  ⚠️ 与需求表的一处**有意偏离**（已在实现报告里回报队长）：该表把 `unavailable` 排在
+ *  `formulaSkipped>0` 之前，但过短选区（如只选一个 `F`）会同时命中两者，按表顺序会显示
+ *  「没能定位到原文公式」——而验收项 A13 要求显示「选区太短，公式未还原」。这里让
+ *  「什么都没还原 + 有过短 chunk」先报「选区太短」：它更准确，也不会误导用户以为译文是准的。 */
+function trNote(resp) {
+  const reason = eqIndex && eqIndex.reason;
+  if (eqIndex && eqIndex.source === 'none' && reason === 'no-mineru-artifact') {
+    return '⚠ 该论文未用 MinerU 转录：原文里的公式在文本层不可读，译文可能不准（顶栏 ∑ 公式 → 「用 MinerU 重新转录」）';
+  }
+  if (reason === 'no-equations') return '⚠ MinerU 产物里没有公式块：公式可能不准';
+  if (reason === 'bad-artifact') return '⚠ MinerU 产物损坏或不可读，已忽略：公式可能不准';
+  if (resp.formulaLost > 0) return `⚠ 有 ${resp.formulaLost} 个公式未原样保留，请对照原文`;
+  if (resp.formulaSkipped > 0 && resp.formulaApplied === 0) return '⚠ 选区太短，公式未还原';
+  if (resp.formulaStatus === 'unavailable' && resp.hasBlockIndex) return '⚠ 没能定位到原文公式，译文可能不准';
+  if (resp.formulaStatus === 'partial') return '⚠ 部分公式未能还原，译文可能不准';
+  if (resp.formulaSkipped > 0) return '⚠ 选区太短，公式未还原';
+  return '';   // applied / formulaTotal===0：不显示任何提示
+}
+
+/** 失败反馈（§3.7② 表，逐条）。返回 {status, toast}：气泡状态行与 toast 的措辞不同处照表分开。 */
+function trFailure(e) {
+  if (e && e.clientTimeout) return { status: '翻译超时，请重试', toast: '翻译超时，请重试' };
+  if (e && e.code === 'timeout') return { status: '翻译超时，请重试', toast: '翻译超时，请重试' };
+  if (e && e.code === 'network') return { status: '翻译失败：无法连接端点', toast: '翻译失败：无法连接端点' };
+  const up = e && e.upstreamStatus;
+  if (up === 401 || up === 403) return { status: '翻译失败：端点拒绝（请检查 API key）', toast: `翻译失败：端点拒绝（HTTP ${up}）` };
+  if (up === 429) return { status: '翻译失败：请求过于频繁，稍后再试', toast: '翻译失败：请求过于频繁，稍后再试' };
+  if (typeof up === 'number' && up >= 500) return { status: '翻译失败：端点错误（HTTP 5xx）', toast: '翻译失败：端点错误（HTTP 5xx）' };
+  const m = '翻译失败：' + ((e && e.message) || '未知原因');
+  return { status: m, toast: m };
+}
+
+/** 划词翻译入口（#ask-translate.onclick）。 */
+async function translateSelection() {
+  // 中文列（分屏，doc==='zh'）不参与：几何只对原文页成立（R-07；按钮本身也不会显示）
+  if (!current || !askSelection || askSelection.kind !== 'text' || zhVariant !== null) return;
+  if ((askSelection.doc ?? 'orig') !== 'orig') return;
+  if (trBusy) return;
+  const range = askSelection.range;
+  if (!range || !range.startContainer || range.startContainer.isConnected === false) {
+    toast('页面已重绘，请重新选择', 4000);   // R5：绝不缓存矩形，也不静默失败
+    return;
+  }
+  // 用户点按钮时浏览器可能已把选区清掉：先把存下来的 Range 放回去，rects 才取得到
+  const sel = window.getSelection();
+  if (sel && sel.isCollapsed && typeof sel.addRange === 'function') {
+    try { sel.removeAllRanges(); sel.addRange(range); } catch { /* 失效选区：下面按空选区处理 */ }
+  }
+  let text = '';
+  try { text = String(range.toString() || ''); } catch { text = ''; }
+  if (!text.trim()) { toast('选区已失效，请重新选择', 4000); return; }
+  const chars = collectSelectionChars(range);
+  const chunks = buildChunks(chars, eqItemsFor);
+  if (!chunks.length) { toast('选区已失效，请重新选择', 4000); return; }
+  if (chars.length > MAX_SELECTION_CHARS) toast(`选区过长，只翻译前 ${MAX_SELECTION_CHARS} 字符`, 4000);
+
+  askPop.style.display = 'none';       // 同一锚点必然重叠 ⇒ 气泡「变成」译文气泡（§3.1）
+  showTrPop('翻译中…', '', '');
+  trBusy = true;
+  const seq = ++trSeq;
+  const ac = new AbortController();
+  let clientTimeout = false;
+  const timer = setTimeout(() => { clientTimeout = true; ac.abort(); }, TR_CLIENT_TIMEOUT_MS);
+  // 诊断可读性：记录本次送出的 chunk 规模（不含文本内容、不含 key）
+  const charsSent = chunks.reduce((n, c) => n + (c.kind === 'text' ? c.text.length : c.latex.length), 0);
+  try {
+    const resp = await api('/translate-selection', {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ ...current, chunks }),
+      signal: ac.signal,
+    });
+    if (seq !== trSeq) return;          // 过期保护：用户已换选区/换文献
+    showTrPop('', resp.translation, trNote(resp));
+  } catch (e) {
+    if (seq !== trSeq) return;
+    if (clientTimeout) e.clientTimeout = true;
+    if (e && e.code === 'no-endpoint') {
+      // 未配置端点：打开既有设置浮层，保存成功后自动重试这次翻译（§3.7①）
+      showTrPop('未配置翻译端点', '', '在上面的设置里填好端点并保存，会自动重试这次翻译');
+      cfgRetryTranslate = true;
+      openCfgPop(false);
+      return;
+    }
+    const f = trFailure(e);
+    showTrPop(f.status, '', '');
+    toast(f.toast + `（选区 ${charsSent} 字符）`, 8000);
+  } finally {
+    clearTimeout(timer);
+    if (seq === trSeq) trBusy = false;
+  }
+}
+
+$('ask-translate').onclick = () => translateSelection();
+document.addEventListener('mousedown', (e) => { if (!trPop.contains(e.target)) hideTrPop(); });
+document.addEventListener('keydown', (e) => { if (e.key === 'Escape') hideTrPop(); });
+
+/* =====================================================================================
+   分屏对照（模式 B）：原文 PDF ↔ -zh.pdf 并排同步滚动 —— §4.2/§4.4
+   · 两列各自一个 pdf.js 文档；全局 pdfDoc **保持指向原文**（既有逻辑零改动）
+   · zhVariant 保持 null ⇒ eqHotEnabled()/公式面板/适宽分支继续按「原文」工作（C17）
+   · 热区只在原文列铺（paintEqLayer 按 pageDiv.dataset.doc 早退）、只在原文列命中（C18/R7）
+   ===================================================================================== */
+const SPLIT_MIN_WIDTH = 640;   // 冻结：面板太窄不做分屏（§4.2）
+let pdfDocZh = null;
+let splitSyncing = false;
+let splitRaf = 0;
+let splitWarned = false;
+
+const rafFn = (fn) => (typeof window.requestAnimationFrame === 'function' ? window.requestAnimationFrame(fn) : setTimeout(fn, 0));
+const crafFn = (id) => { if (typeof window.cancelAnimationFrame === 'function') window.cancelAnimationFrame(id); else clearTimeout(id); };
+
+/** 纯函数：滚动位置 → 「顶部页号 + 页内比例」（§4.2 锚点）。
+ *  pages: [{page, offsetTop, offsetHeight}]，按 DOM 序。 */
+function anchorOf(pages, scrollTop) {
+  if (!pages || !pages.length) return null;
+  let page = pages[pages.length - 1];
+  for (const p of pages) { if (p.offsetTop + p.offsetHeight > scrollTop) { page = p; break; } }
+  return { page: page.page, ratio: (scrollTop - page.offsetTop) / Math.max(1, page.offsetHeight) };
+}
+
+/** 纯函数：锚点 → 目标列 scrollTop。页数相同（实测常态 19/19）走同页号；不同则按比例映射，
+ *  并让调用方给出「页数不一致」的一次性提示。 */
+function syncTargetOf(anchor, targetPages, srcPageCount) {
+  if (!anchor || !targetPages || !targetPages.length) return null;
+  const n = targetPages.length;
+  let mismatch = false;
+  let idx = targetPages.findIndex((p) => p.page === anchor.page);
+  if (idx < 0) {
+    mismatch = true;
+    idx = Math.min(n - 1, Math.max(0, Math.round((anchor.page - 1) * n / Math.max(1, srcPageCount | 0))));
+  } else if (srcPageCount && srcPageCount !== n) {
+    mismatch = true;
+  }
+  const p = targetPages[idx];
+  return { top: p.offsetTop + anchor.ratio * p.offsetHeight, mismatch };
+}
+
+/** 一列的页几何（DOM 序）。 */
+function columnPages(box) {
+  return [...box.children].filter((c) => c.className === 'page')
+    .map((d) => ({ page: +d.dataset.page || 1, offsetTop: d.offsetTop, offsetHeight: d.offsetHeight }));
+}
+
+const splitCols = () => [
+  { pane: $('pdf-pane'), box: $('pdf-pages') },
+  { pane: $('pdf-pane-zh'), box: $('pdf-pages-zh') },
+];
+
+/* =====================================================================================
+   同步滚动开关（模式 B 的可选项）—— 两处入口（分屏控件旁 + dsh 设置面板）、全局记忆、默认开
+   · 持久化键 `dpr.syncScroll`（'1'/'0'）：**故意不带 topic/name**，也**不在**
+     `dpr.variant.` / `dpr.sessionN.` 两个前缀里 —— lib/client.js 的改名搬家（migrateLsKeys）
+     只搬那两个前缀，所以论文/专题改名既不会搬它、更不会丢它（全局键本来就没有跟着某篇走的身份）。
+     取值缺省 = 开：与改造前「两列被 rAF 强行同步」的既有行为一致，老用户观感不变。
+   · 设置面板在**另一个文档**里（阅读器是同源 iframe）：两处靠 localStorage 的 storage 事件互通
+     （它只对**其他**文档触发，天然不会回声）——任一处改动，另一处立即反映。
+   · 关掉只关「持续联动」：进分屏/重渲时的一次性对齐（alignSplit）仍然执行，否则两列会停在不同页。
+   ===================================================================================== */
+const SYNC_SCROLL_KEY = 'dpr.syncScroll';
+let syncScroll = readSyncPref();
+/** 最后一次被用户滚过的那一列（关同步时也记）：重开同步时以它为基准对齐 —— 用户停在哪儿就对齐到哪儿。 */
+let splitLeadPane = null;
+
+/** 读偏好：只有显式的 '0' 算关，其余（含缺失/脏值）都算开。 */
+function readSyncPref() {
+  try { return localStorage.getItem(SYNC_SCROLL_KEY) !== '0'; } catch { return true; }   // 隐私模式读不了 → 默认开
+}
+function persistSyncPref() {
+  try { localStorage.setItem(SYNC_SCROLL_KEY, syncScroll ? '1' : '0'); } catch { /* 隐私模式写不了：本次会话内仍然生效 */ }
+}
+
+/** 开关控件（分屏控件旁）：**只在分屏（模式 B）下可见** —— 模式 A（-dual.pdf 一个 PDF 里并排嵌好）
+ *  与原文/译文视图都只有一个滚动条，本开关没有意义；隐藏而不是留个死控件。 */
+function updateSyncToggle() {
+  const b = $('sync-toggle');
+  if (!b) return;
+  b.style.display = viewMode === 'split' ? '' : 'none';
+  // 状态换图标（与 mode-toggle 的 paged/scroll、zh-toggle 的 translate/spin 同法）：
+  // data-icon 跟着渲染出来的图标走，图标本身由 iconHtml 统一给出（class="ic"、size、aria-hidden）
+  const icon = syncScroll ? 'sync' : 'syncOff';
+  b.dataset.icon = icon;
+  b.innerHTML = iconHtml(icon);
+  b.classList.toggle('active', syncScroll);
+  b.title = syncScroll
+    ? '同步滚动 / Sync scroll：开（两列一起滚，点击关闭）'
+    : '同步滚动 / Sync scroll：关（两列各自独立滚动，点击打开并对齐回当前页）';
+}
+
+/** 唯一写入口（按钮点击 / 设置面板的 storage 事件都走这里）：落持久化 → 刷新控件 → 打开时立刻对齐。 */
+function setSyncScroll(on, { persist = true, realign = true } = {}) {
+  syncScroll = !!on;
+  if (persist) persistSyncPref();
+  updateSyncToggle();
+  if (syncScroll && realign) alignSplit(currentLeadCol());
+}
+
+/** 重开同步时的基准列：用户最后滚过的那一列；没滚过（或那列已不在）就用原文列。 */
+function currentLeadCol() {
+  const cols = splitCols();
+  return cols.find((c) => c.pane === splitLeadPane) || cols[0];
+}
+
+/** 一次性对齐：把**跟随列**滚到基准列当前锚点对应的位置。
+ *  与 onSplitScroll 的区别是**不看 syncScroll** —— 进分屏 / 重渲 / 重开同步都必须先把两列摆到同一页，
+ *  否则用户看到「两列停在不同页」会以为坏了（关同步只关持续联动，不关「一开始就对齐」）。 */
+function alignSplit(src) {
+  if (viewMode !== 'split') return;
+  const other = splitCols().find((c) => c.pane !== src.pane);
+  if (!other) return;
+  const srcPages = columnPages(src.box);
+  const target = syncTargetOf(anchorOf(srcPages, src.pane.scrollTop), columnPages(other.box), srcPages.length);
+  if (!target) return;
+  splitSyncing = true;              // 跟随引起的 scroll 事件在下一帧被守卫吞掉（与 onSplitScroll 同法）
+  crafFn(splitRaf);
+  splitRaf = rafFn(() => {
+    try {
+      other.pane.scrollTop = target.top;
+      if (target.mismatch && !splitWarned) { splitWarned = true; toast('⚠ 中文版页数与原文不一致，按比例同步', 4000); }
+    } finally {
+      splitSyncing = false;
+    }
+  });
+}
+
+/** 分屏控件旁的开关：只在分屏下可见；模式 A / 单列下点不到，也绝不报错。 */
+$('sync-toggle').onclick = () => {
+  if (viewMode !== 'split') return;
+  setSyncScroll(!syncScroll);
+};
+
+/** 设置面板（dsh 设置 → 论文伴读）改了同一个键 → 阅读器立即反映（含重新打开同步时的一次性对齐）。
+ *  只在值真的变了的时候动：storage 只对**其他**文档触发，这里也不回写（不回写就不会回声）。 */
+window.addEventListener('storage', (e) => {
+  if (!e || e.key !== SYNC_SCROLL_KEY) return;
+  const next = e.newValue !== '0';
+  if (next === syncScroll) return;
+  setSyncScroll(next, { persist: false });
+});
+
+/** 滚动同步：主导方 = 用户正在滚的那一列；rAF 节流 + 守卫吞掉回声（§4.2/R7）。
+ *  syncScroll=false 时本函数直接早退 ⇒ 两列各自独立滚动（不节流、也不强行对齐）。 */
+function onSplitScroll(src) {
+  if (viewMode !== 'split' || splitSyncing || !syncScroll) return;
+  const other = splitCols().find((c) => c.pane !== src.pane);
+  if (!other) return;
+  splitSyncing = true;              // 跟随引起的 scroll 事件被守卫吞掉
+  crafFn(splitRaf);
+  splitRaf = rafFn(() => {
+    try {
+      // 排到这一帧时开关可能已被关掉（用户点了开关、或面板刚同步过来）：在飞的回调也不得再拉列，
+      // 否则「关掉后各自独立」会在下一帧被自己打破（F1 同一族问题）。
+      if (!syncScroll) return;
+      const srcPages = columnPages(src.box);
+      const a = anchorOf(srcPages, src.pane.scrollTop);
+      const t = syncTargetOf(a, columnPages(other.box), srcPages.length);
+      if (t) {
+        other.pane.scrollTop = t.top;   // behavior 默认 auto：不做平滑动画（会和同步互相打架）
+        if (t.mismatch && !splitWarned) { splitWarned = true; toast('⚠ 中文版页数与原文不一致，按比例同步', 4000); }
+      }
+    } finally {
+      splitSyncing = false;
+    }
+  });
+}
+
+/** 渲染一列的若干页（滚动=全量、翻页=curPage）。热区由 paintPage 按页节点的 data-doc 决定。 */
+async function renderColumn(doc, docKey, container, pages, token, scale) {
+  for (const i of pages) {
+    if (token !== renderToken) return;
+    const page = await doc.getPage(i);
+    if (token !== renderToken) return;
+    const viewport = page.getViewport({ scale });
+    const div = makePageNode(i, viewport, docKey);
+    container.appendChild(div);
+    await paintPage(page, div, viewport, token);
+    if (token !== renderToken) return;
+  }
+}
+
+/** 清空前捕获一列的滚动锚点：优先「页号 + 页内比例」（此刻旧页节点还在，页内几何有效）；
+ *  页节点不可用（并发重渲刚好清空过容器）时退回滚动比例锚点 —— 与 renderAllPages 同口径，
+ *  绝不把锚点归零成「回到第一页」。 */
+function captureScrollAnchor(pane, box) {
+  const pages = columnPages(box);
+  const a = pages.length ? anchorOf(pages, pane.scrollTop) : null;
+  if (a) return a;
+  const range = pane.scrollHeight - pane.clientHeight;
+  return { ratio: range > 0 ? pane.scrollTop / range : 0 };
+}
+
+/** 把一列恢复到自己捕获的锚点：优先「同页号 + 页内比例」（zoom / dppx 前后都落回**同一页**，
+ *  不因页面间 gap/padding 造成的比例漂移而挪页）；该页这次没有（页数变了/节点缺失）时退回滚动比例。 */
+function restoreScrollAnchor(pane, box, anchor) {
+  if (anchor && anchor.page != null) {
+    const p = columnPages(box).find((x) => x.page === anchor.page);
+    if (p) { pane.scrollTop = p.offsetTop + anchor.ratio * p.offsetHeight; return; }
+  }
+  const range = pane.scrollHeight - pane.clientHeight;
+  pane.scrollTop = (anchor && typeof anchor.ratio === 'number' ? anchor.ratio : 0) * Math.max(0, range);
+}
+
+/** 中文列这次重渲前是否有一个「和即将渲染的形态可比」的位置：重渲前的页数必须等于这次要渲染的页数
+ *  （还没渲过 / 页数变了 / 翻页↔滚动切换都不可比 —— 那些情况沿用统一对齐，见 renderSplit 尾注）。 */
+function zhOwnAnchorUsable(box, doc, paged) {
+  const before = columnPages(box).length;
+  if (before === 0) return false;
+  return before === (doc ? (paged ? 1 : doc.numPages) : 0);
+}
+
+/** 分屏全量渲染入口：两列同时渲（滚动=各列全量、翻页=两列同渲 curPage）。 */
+async function renderSplit() {
+  if (viewMode !== 'split') return rerender();
+  if (!pdfDoc) return;
+  const pane = $('pdf-pane');
+  if (pane.clientHeight === 0) { pendingRerender = true; return; } // 与既有渲染入口同一条守卫
+  const token = ++renderToken;
+  const scale = zoomScale;
+  const origBox = $('pdf-pages'), zhBox = $('pdf-pages-zh');
+  const range = pane.scrollHeight - pane.clientHeight;
+  const anchorRatio = range > 0 ? pane.scrollTop / range : 0;
+  // F1：清空前**各自**记下两列的锚点（此刻旧页节点还在）。同步关着时两列各回各的 ——
+  // 关掉同步的全部意义就是「两列读不同位置」，zoom / dppx / resize 一下不该把这个意图抹掉。
+  const zhPane = $('pdf-pane-zh');
+  const origAnchor = captureScrollAnchor(pane, origBox);
+  const zhAnchor = captureScrollAnchor(zhPane, zhBox);
+  const paged = pageMode === 'paged';
+  const zhOwn = zhOwnAnchorUsable(zhBox, pdfDocZh, paged);
+  origBox.innerHTML = '';
+  zhBox.innerHTML = '';
+  clearEqGeometry();   // 旧页几何 + 跨列残留的 hover/hit 描边一起作废
+  $('zoom-label').textContent = Math.round(scale / 1.5 * 100) + '%';
+  origBox.classList.toggle('paged', paged);
+  zhBox.classList.toggle('paged', paged);
+  curPage = Math.min(Math.max(1, curPage), pdfDoc.numPages);
+  updatePager();
+  const origList = paged ? [curPage] : Array.from({ length: pdfDoc.numPages }, (_, i) => i + 1);
+  await renderColumn(pdfDoc, 'orig', origBox, origList, token, scale);
+  if (token !== renderToken) return;
+  if (pdfDocZh) {
+    const zhPage = Math.min(Math.max(1, curPage), pdfDocZh.numPages);
+    const zhList = paged ? [zhPage] : Array.from({ length: pdfDocZh.numPages }, (_, i) => i + 1);
+    await renderColumn(pdfDocZh, 'zh', zhBox, zhList, token, scale);
+    if (token !== renderToken) return;
+  }
+  // 锚点恢复：重渲后两列各自回到重渲前的位置。
+  //  · 同步开着 / 刚进分屏（中文列还没有可比的位置）：**既有语义一字不动** —— 原文列按滚动比例回位，
+  //    中文列统一对齐到原文列（「进分屏的一次性对齐不看开关」是评审已裁定必要的行为，保持）；
+  //  · 同步关着且中文列有**同形态**的重渲前位置（F1 修法）：两列各回各的锚点 —— 不能让一次
+  //    zoom / dppx / resize 把「两列读不同位置」的意图抹掉。
+  if (!paged) {
+    if (syncScroll || !zhOwn) {
+      const newRange = pane.scrollHeight - pane.clientHeight;
+      pane.scrollTop = anchorRatio * Math.max(0, newRange);
+      splitSyncing = false;
+      alignSplit(splitCols()[0]);
+    } else {
+      restoreScrollAnchor(pane, origBox, origAnchor);
+      restoreScrollAnchor(zhPane, zhBox, zhAnchor);
+      splitSyncing = false;
+      crafFn(splitRaf);     // 作废可能在飞的对齐/联动回调：别让它下一帧再把中文列拉回原文列
+      splitRaf = 0;
+    }
+  }
+  observePages();      // 只观察原文列（#pdf-pages .page 的 id 限定必须保持）
+}
+
+/** 进入分屏（或 openPaper 恢复分屏）：拉原文 + -zh.pdf 两个文档，两列同渲。 */
+async function openSplit() {
+  if (!current || !zhState.zh) return;
+  if (window.innerWidth < SPLIT_MIN_WIDTH) {
+    toast('面板太窄，请把阅读器拉宽后再用分屏对照', 4000);
+    if (viewMode === 'split') await setViewMode('orig');
+    return;
+  }
+  // pdf.js 必须先就绪（与 loadPdf 同一条通道）：openPaper 恢复「分屏」时页脚的经典脚本还在解析期，
+  // 动态 import 尚未完成 —— 直接触 pdfjsLib 会 ReferenceError，表现为
+  // 「打开中文版失败：pdfjsLib is not defined，已退回原文」+ 持久化写空（t3 报告 F3，6 次跑 5 次失败）。
+  await ensurePdfjs();
+  $('split-wrap').classList.add('on');
+  $('pdf-pane-zh').style.display = '';
+  splitWarned = false;
+  $('empty').style.display = 'none';
+  $('pager').style.display = '';
+  $('mode-toggle').style.display = '';
+  if (pdfDocZh) { try { await pdfDocZh.destroy?.(); } catch { /* 旧文档已释放 */ } pdfDocZh = null; }
+  try {
+    pdfDocZh = await pdfjsLib.getDocument({ url: pdfUrl('zh') }).promise;
+  } catch (e) {
+    // -zh.pdf 拿不到（被删/损坏）：回落原文 + 如实提示，不静默失败
+    await setViewMode('orig');
+    toast('打开中文版失败：' + (e && e.message ? e.message : e) + '，已退回原文', 6000);
+    return;
+  }
+  await loadPdf(pdfUrl(null), { deferRender: true }); // 原文列（pdfDoc 恒指原文），本函数自己安排渲染
+  // 分屏适宽：按较窄的那一列算一次（等价于 fitToWidth，但不让它触发一次多余的单列渲染）
+  const w = fitPaneWidth();
+  if (w > 0) {
+    const p1 = await pdfDoc.getPage(1);
+    zoomScale = Math.min(4.5, Math.max(0.6, w / p1.getViewport({ scale: 1 }).width));
+  }
+  await renderSplit();
+  attachSplitScroll();
+}
+
+/** 退出分屏：拆掉中文列、释放中文文档、同步监听。 */
+function teardownSplit() {
+  $('split-wrap').classList.remove('on');
+  $('pdf-pane-zh').style.display = 'none';
+  $('pdf-pages-zh').innerHTML = '';
+  $('pdf-pages-zh').classList.remove('paged');
+  splitCols().forEach((c) => { c.pane.onscroll = null; });
+  splitSyncing = false;
+  splitLeadPane = null;   // 分屏退出：上一轮「最后滚过的那一列」作废（下次进分屏回到原文列为准）
+  crafFn(splitRaf);
+  if (pdfDocZh) { try { pdfDocZh.destroy?.(); } catch { /* 已释放 */ } }
+  pdfDocZh = null;
+}
+
+/** 两列的滚动监听（各自一个，**不**共用一个滚动容器——R7 明令）。 */
+function attachSplitScroll() {
+  splitCols().forEach((col) => {
+    // 关掉同步时也记「最后滚过的那一列」：重开同步要按它对齐（见 setSyncScroll/currentLeadCol）
+    col.pane.onscroll = () => { splitLeadPane = col.pane; onSplitScroll(col); };
+  });
+}
+
 /* ================= 启动：URL 参数 > localStorage > 第一篇 ================= */
 async function bootstrap() {
   const params = new URLSearchParams(location.search);
diff --git a/reader/vendor/KaTeX_AMS-Regular.woff2 b/reader/vendor/KaTeX_AMS-Regular.woff2
new file mode 100644
index 0000000..0acaaff
Binary files /dev/null and b/reader/vendor/KaTeX_AMS-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Caligraphic-Bold.woff2 b/reader/vendor/KaTeX_Caligraphic-Bold.woff2
new file mode 100644
index 0000000..f390922
Binary files /dev/null and b/reader/vendor/KaTeX_Caligraphic-Bold.woff2 differ
diff --git a/reader/vendor/KaTeX_Caligraphic-Regular.woff2 b/reader/vendor/KaTeX_Caligraphic-Regular.woff2
new file mode 100644
index 0000000..75344a1
Binary files /dev/null and b/reader/vendor/KaTeX_Caligraphic-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Fraktur-Bold.woff2 b/reader/vendor/KaTeX_Fraktur-Bold.woff2
new file mode 100644
index 0000000..395f28b
Binary files /dev/null and b/reader/vendor/KaTeX_Fraktur-Bold.woff2 differ
diff --git a/reader/vendor/KaTeX_Fraktur-Regular.woff2 b/reader/vendor/KaTeX_Fraktur-Regular.woff2
new file mode 100644
index 0000000..735f694
Binary files /dev/null and b/reader/vendor/KaTeX_Fraktur-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Main-Bold.woff2 b/reader/vendor/KaTeX_Main-Bold.woff2
new file mode 100644
index 0000000..ab2ad21
Binary files /dev/null and b/reader/vendor/KaTeX_Main-Bold.woff2 differ
diff --git a/reader/vendor/KaTeX_Main-BoldItalic.woff2 b/reader/vendor/KaTeX_Main-BoldItalic.woff2
new file mode 100644
index 0000000..5931794
Binary files /dev/null and b/reader/vendor/KaTeX_Main-BoldItalic.woff2 differ
diff --git a/reader/vendor/KaTeX_Main-Italic.woff2 b/reader/vendor/KaTeX_Main-Italic.woff2
new file mode 100644
index 0000000..b50920e
Binary files /dev/null and b/reader/vendor/KaTeX_Main-Italic.woff2 differ
diff --git a/reader/vendor/KaTeX_Main-Regular.woff2 b/reader/vendor/KaTeX_Main-Regular.woff2
new file mode 100644
index 0000000..eb24a7b
Binary files /dev/null and b/reader/vendor/KaTeX_Main-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Math-BoldItalic.woff2 b/reader/vendor/KaTeX_Math-BoldItalic.woff2
new file mode 100644
index 0000000..2965702
Binary files /dev/null and b/reader/vendor/KaTeX_Math-BoldItalic.woff2 differ
diff --git a/reader/vendor/KaTeX_Math-Italic.woff2 b/reader/vendor/KaTeX_Math-Italic.woff2
new file mode 100644
index 0000000..215c143
Binary files /dev/null and b/reader/vendor/KaTeX_Math-Italic.woff2 differ
diff --git a/reader/vendor/KaTeX_SansSerif-Bold.woff2 b/reader/vendor/KaTeX_SansSerif-Bold.woff2
new file mode 100644
index 0000000..cfaa3bd
Binary files /dev/null and b/reader/vendor/KaTeX_SansSerif-Bold.woff2 differ
diff --git a/reader/vendor/KaTeX_SansSerif-Italic.woff2 b/reader/vendor/KaTeX_SansSerif-Italic.woff2
new file mode 100644
index 0000000..349c06d
Binary files /dev/null and b/reader/vendor/KaTeX_SansSerif-Italic.woff2 differ
diff --git a/reader/vendor/KaTeX_SansSerif-Regular.woff2 b/reader/vendor/KaTeX_SansSerif-Regular.woff2
new file mode 100644
index 0000000..a90eea8
Binary files /dev/null and b/reader/vendor/KaTeX_SansSerif-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Script-Regular.woff2 b/reader/vendor/KaTeX_Script-Regular.woff2
new file mode 100644
index 0000000..b3048fc
Binary files /dev/null and b/reader/vendor/KaTeX_Script-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Size1-Regular.woff2 b/reader/vendor/KaTeX_Size1-Regular.woff2
new file mode 100644
index 0000000..c5a8462
Binary files /dev/null and b/reader/vendor/KaTeX_Size1-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Size2-Regular.woff2 b/reader/vendor/KaTeX_Size2-Regular.woff2
new file mode 100644
index 0000000..e1bccfe
Binary files /dev/null and b/reader/vendor/KaTeX_Size2-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Size3-Regular.woff2 b/reader/vendor/KaTeX_Size3-Regular.woff2
new file mode 100644
index 0000000..249a286
Binary files /dev/null and b/reader/vendor/KaTeX_Size3-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Size4-Regular.woff2 b/reader/vendor/KaTeX_Size4-Regular.woff2
new file mode 100644
index 0000000..680c130
Binary files /dev/null and b/reader/vendor/KaTeX_Size4-Regular.woff2 differ
diff --git a/reader/vendor/KaTeX_Typewriter-Regular.woff2 b/reader/vendor/KaTeX_Typewriter-Regular.woff2
new file mode 100644
index 0000000..771f1af
Binary files /dev/null and b/reader/vendor/KaTeX_Typewriter-Regular.woff2 differ
diff --git a/reader/vendor/katex.LICENSE b/reader/vendor/katex.LICENSE
new file mode 100644
index 0000000..37c6433
--- /dev/null
+++ b/reader/vendor/katex.LICENSE
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2013-2020 Khan Academy and other contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/reader/vendor/katex.NOTICE.md b/reader/vendor/katex.NOTICE.md
new file mode 100644
index 0000000..feecad2
--- /dev/null
+++ b/reader/vendor/katex.NOTICE.md
@@ -0,0 +1,26 @@
+# KaTeX（vendored，离线；**扁平放置**）
+
+> **为什么这些文件是扁平的（不放在 `vendor/katex/` 子目录）**：阅读器的静态资源路由
+> `/paper-reader/vendor/*` 只服务**扁平文件名**（`^[\w.-]+$`，不含 `/`，且只放行
+> `.mjs/.js/.css/.map/.woff2/.woff/.ttf` 这些后缀）。子目录形态会让 `katex.min.js` 直接 400
+> `bad asset name`、CSS 里的相对 `url(fonts/…woff2)` 也取不到 ⇒ `window.katex` 不存在 ⇒
+> **每个数学段都降级**（这正是 PR #7「公式经常未渲染」的主因，见 docs/pr7-render-diagnosis.md 的 P0）。
+> 拉平是最安全的修法：不动路由的路径校验逻辑、不新增 `..`/编码变形的穿越面，
+> 且 `test/reader-vendor-http.test.mjs` 会真发 HTTP 把页面/CSS 引到的每个资源逐个取 200。
+
+- **版本**：0.16.22
+- **来源**：npm 包 `katex@0.16.22`（`https://registry.npmjs.org/katex/-/katex-0.16.22.tgz`，
+  sha256 `e9e0d167db3175481cbadaff38e8d90b130f6a3ddb451a47e43c577fd511f365`）；
+  上游仓库 `https://github.com/KaTeX/KaTeX`（`https://katex.org`）。
+- **许可证**：MIT（全文见同目录 `LICENSE`，Copyright (c) 2013-2020 Khan Academy and other contributors）。
+- **扁平文件**（都在 `reader/vendor/`）：`katex.min.js`（276,701 B）、`katex.min.css`（23,352 B）、
+  `KaTeX_*.woff2`（20 个，259,792 B）、`katex.LICENSE`、`katex.NOTICE.md`。CSS 内部的字体 URL 已从 `fonts/X.woff2` 改写为同目录 `X.woff2`。
+  **刻意省略** woff/ttf 两种字体格式：CSS 的 `@font-face` 以 `.woff2` 为首选源，
+  当前目标运行环境（Electron/Chromium、现代 Safari/Firefox）均支持 woff2；省略可把体积从 ~1.05 MB 降到 ~254 KB。
+- **为什么这不算「新增依赖」**（可直接写进 PR）：
+  「KaTeX 是**随包分发的静态资源**，不是依赖树里的包 —— 它没有进入 `package.json` / lockfile，不参与
+  安装或解析；`pnpm install` 的依赖集合、`node_modules` 内容与构建产物都不变。选 vendored 而非 `npm i katex`
+  的原因：论文伴读是**离线场景**，读者页面不允许任何运行时 CDN 请求；把渲染器与字体随插件一起分发，
+  才能保证断网可用、且版本与字体一一对应（不会出现「CSS 更新了但字体没跟上」的半坏渲染）。」
+- **更新方式**：`npm pack katex@<version>` → 覆盖 `reader/vendor/` 下的 `katex.min.js` / `katex.min.css` / `KaTeX_*.woff2` / `katex.LICENSE`，
+  并同步上面的版本号、URL 与 sha256。
diff --git a/reader/vendor/katex.min.css b/reader/vendor/katex.min.css
new file mode 100644
index 0000000..7fdabc2
--- /dev/null
+++ b/reader/vendor/katex.min.css
@@ -0,0 +1 @@
+@font-face{font-family:KaTeX_AMS;font-style:normal;font-weight:400;src:url(KaTeX_AMS-Regular.woff2) format("woff2"),url(KaTeX_AMS-Regular.woff) format("woff"),url(KaTeX_AMS-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Caligraphic;font-style:normal;font-weight:700;src:url(KaTeX_Caligraphic-Bold.woff2) format("woff2"),url(KaTeX_Caligraphic-Bold.woff) format("woff"),url(KaTeX_Caligraphic-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Caligraphic;font-style:normal;font-weight:400;src:url(KaTeX_Caligraphic-Regular.woff2) format("woff2"),url(KaTeX_Caligraphic-Regular.woff) format("woff"),url(KaTeX_Caligraphic-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Fraktur;font-style:normal;font-weight:700;src:url(KaTeX_Fraktur-Bold.woff2) format("woff2"),url(KaTeX_Fraktur-Bold.woff) format("woff"),url(KaTeX_Fraktur-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Fraktur;font-style:normal;font-weight:400;src:url(KaTeX_Fraktur-Regular.woff2) format("woff2"),url(KaTeX_Fraktur-Regular.woff) format("woff"),url(KaTeX_Fraktur-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:normal;font-weight:700;src:url(KaTeX_Main-Bold.woff2) format("woff2"),url(KaTeX_Main-Bold.woff) format("woff"),url(KaTeX_Main-Bold.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:italic;font-weight:700;src:url(KaTeX_Main-BoldItalic.woff2) format("woff2"),url(KaTeX_Main-BoldItalic.woff) format("woff"),url(KaTeX_Main-BoldItalic.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:italic;font-weight:400;src:url(KaTeX_Main-Italic.woff2) format("woff2"),url(KaTeX_Main-Italic.woff) format("woff"),url(KaTeX_Main-Italic.ttf) format("truetype")}@font-face{font-family:KaTeX_Main;font-style:normal;font-weight:400;src:url(KaTeX_Main-Regular.woff2) format("woff2"),url(KaTeX_Main-Regular.woff) format("woff"),url(KaTeX_Main-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Math;font-style:italic;font-weight:700;src:url(KaTeX_Math-BoldItalic.woff2) format("woff2"),url(KaTeX_Math-BoldItalic.woff) format("woff"),url(KaTeX_Math-BoldItalic.ttf) format("truetype")}@font-face{font-family:KaTeX_Math;font-style:italic;font-weight:400;src:url(KaTeX_Math-Italic.woff2) format("woff2"),url(KaTeX_Math-Italic.woff) format("woff"),url(KaTeX_Math-Italic.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:normal;font-weight:700;src:url(KaTeX_SansSerif-Bold.woff2) format("woff2"),url(KaTeX_SansSerif-Bold.woff) format("woff"),url(KaTeX_SansSerif-Bold.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:italic;font-weight:400;src:url(KaTeX_SansSerif-Italic.woff2) format("woff2"),url(KaTeX_SansSerif-Italic.woff) format("woff"),url(KaTeX_SansSerif-Italic.ttf) format("truetype")}@font-face{font-family:"KaTeX_SansSerif";font-style:normal;font-weight:400;src:url(KaTeX_SansSerif-Regular.woff2) format("woff2"),url(KaTeX_SansSerif-Regular.woff) format("woff"),url(KaTeX_SansSerif-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Script;font-style:normal;font-weight:400;src:url(KaTeX_Script-Regular.woff2) format("woff2"),url(KaTeX_Script-Regular.woff) format("woff"),url(KaTeX_Script-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size1;font-style:normal;font-weight:400;src:url(KaTeX_Size1-Regular.woff2) format("woff2"),url(KaTeX_Size1-Regular.woff) format("woff"),url(KaTeX_Size1-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size2;font-style:normal;font-weight:400;src:url(KaTeX_Size2-Regular.woff2) format("woff2"),url(KaTeX_Size2-Regular.woff) format("woff"),url(KaTeX_Size2-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size3;font-style:normal;font-weight:400;src:url(KaTeX_Size3-Regular.woff2) format("woff2"),url(KaTeX_Size3-Regular.woff) format("woff"),url(KaTeX_Size3-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Size4;font-style:normal;font-weight:400;src:url(KaTeX_Size4-Regular.woff2) format("woff2"),url(KaTeX_Size4-Regular.woff) format("woff"),url(KaTeX_Size4-Regular.ttf) format("truetype")}@font-face{font-family:KaTeX_Typewriter;font-style:normal;font-weight:400;src:url(KaTeX_Typewriter-Regular.woff2) format("woff2"),url(KaTeX_Typewriter-Regular.woff) format("woff"),url(KaTeX_Typewriter-Regular.ttf) format("truetype")}.katex{font:normal 1.21em KaTeX_Main,Times New Roman,serif;line-height:1.2;text-indent:0;text-rendering:auto}.katex *{-ms-high-contrast-adjust:none!important;border-color:currentColor}.katex .katex-version:after{content:"0.16.22"}.katex .katex-mathml{clip:rect(1px,1px,1px,1px);border:0;height:1px;overflow:hidden;padding:0;position:absolute;width:1px}.katex .katex-html>.newline{display:block}.katex .base{position:relative;white-space:nowrap;width:-webkit-min-content;width:-moz-min-content;width:min-content}.katex .base,.katex .strut{display:inline-block}.katex .textbf{font-weight:700}.katex .textit{font-style:italic}.katex .textrm{font-family:KaTeX_Main}.katex .textsf{font-family:KaTeX_SansSerif}.katex .texttt{font-family:KaTeX_Typewriter}.katex .mathnormal{font-family:KaTeX_Math;font-style:italic}.katex .mathit{font-family:KaTeX_Main;font-style:italic}.katex .mathrm{font-style:normal}.katex .mathbf{font-family:KaTeX_Main;font-weight:700}.katex .boldsymbol{font-family:KaTeX_Math;font-style:italic;font-weight:700}.katex .amsrm,.katex .mathbb,.katex .textbb{font-family:KaTeX_AMS}.katex .mathcal{font-family:KaTeX_Caligraphic}.katex .mathfrak,.katex .textfrak{font-family:KaTeX_Fraktur}.katex .mathboldfrak,.katex .textboldfrak{font-family:KaTeX_Fraktur;font-weight:700}.katex .mathtt{font-family:KaTeX_Typewriter}.katex .mathscr,.katex .textscr{font-family:KaTeX_Script}.katex .mathsf,.katex .textsf{font-family:KaTeX_SansSerif}.katex .mathboldsf,.katex .textboldsf{font-family:KaTeX_SansSerif;font-weight:700}.katex .mathitsf,.katex .mathsfit,.katex .textitsf{font-family:KaTeX_SansSerif;font-style:italic}.katex .mainrm{font-family:KaTeX_Main;font-style:normal}.katex .vlist-t{border-collapse:collapse;display:inline-table;table-layout:fixed}.katex .vlist-r{display:table-row}.katex .vlist{display:table-cell;position:relative;vertical-align:bottom}.katex .vlist>span{display:block;height:0;position:relative}.katex .vlist>span>span{display:inline-block}.katex .vlist>span>.pstrut{overflow:hidden;width:0}.katex .vlist-t2{margin-right:-2px}.katex .vlist-s{display:table-cell;font-size:1px;min-width:2px;vertical-align:bottom;width:2px}.katex .vbox{align-items:baseline;display:inline-flex;flex-direction:column}.katex .hbox{width:100%}.katex .hbox,.katex .thinbox{display:inline-flex;flex-direction:row}.katex .thinbox{max-width:0;width:0}.katex .msupsub{text-align:left}.katex .mfrac>span>span{text-align:center}.katex .mfrac .frac-line{border-bottom-style:solid;display:inline-block;width:100%}.katex .hdashline,.katex .hline,.katex .mfrac .frac-line,.katex .overline .overline-line,.katex .rule,.katex .underline .underline-line{min-height:1px}.katex .mspace{display:inline-block}.katex .clap,.katex .llap,.katex .rlap{position:relative;width:0}.katex .clap>.inner,.katex .llap>.inner,.katex .rlap>.inner{position:absolute}.katex .clap>.fix,.katex .llap>.fix,.katex .rlap>.fix{display:inline-block}.katex .llap>.inner{right:0}.katex .clap>.inner,.katex .rlap>.inner{left:0}.katex .clap>.inner>span{margin-left:-50%;margin-right:50%}.katex .rule{border:0 solid;display:inline-block;position:relative}.katex .hline,.katex .overline .overline-line,.katex .underline .underline-line{border-bottom-style:solid;display:inline-block;width:100%}.katex .hdashline{border-bottom-style:dashed;display:inline-block;width:100%}.katex .sqrt>.root{margin-left:.2777777778em;margin-right:-.5555555556em}.katex .fontsize-ensurer.reset-size1.size1,.katex .sizing.reset-size1.size1{font-size:1em}.katex .fontsize-ensurer.reset-size1.size2,.katex .sizing.reset-size1.size2{font-size:1.2em}.katex .fontsize-ensurer.reset-size1.size3,.katex .sizing.reset-size1.size3{font-size:1.4em}.katex .fontsize-ensurer.reset-size1.size4,.katex .sizing.reset-size1.size4{font-size:1.6em}.katex .fontsize-ensurer.reset-size1.size5,.katex .sizing.reset-size1.size5{font-size:1.8em}.katex .fontsize-ensurer.reset-size1.size6,.katex .sizing.reset-size1.size6{font-size:2em}.katex .fontsize-ensurer.reset-size1.size7,.katex .sizing.reset-size1.size7{font-size:2.4em}.katex .fontsize-ensurer.reset-size1.size8,.katex .sizing.reset-size1.size8{font-size:2.88em}.katex .fontsize-ensurer.reset-size1.size9,.katex .sizing.reset-size1.size9{font-size:3.456em}.katex .fontsize-ensurer.reset-size1.size10,.katex .sizing.reset-size1.size10{font-size:4.148em}.katex .fontsize-ensurer.reset-size1.size11,.katex .sizing.reset-size1.size11{font-size:4.976em}.katex .fontsize-ensurer.reset-size2.size1,.katex .sizing.reset-size2.size1{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size2.size2,.katex .sizing.reset-size2.size2{font-size:1em}.katex .fontsize-ensurer.reset-size2.size3,.katex .sizing.reset-size2.size3{font-size:1.1666666667em}.katex .fontsize-ensurer.reset-size2.size4,.katex .sizing.reset-size2.size4{font-size:1.3333333333em}.katex .fontsize-ensurer.reset-size2.size5,.katex .sizing.reset-size2.size5{font-size:1.5em}.katex .fontsize-ensurer.reset-size2.size6,.katex .sizing.reset-size2.size6{font-size:1.6666666667em}.katex .fontsize-ensurer.reset-size2.size7,.katex .sizing.reset-size2.size7{font-size:2em}.katex .fontsize-ensurer.reset-size2.size8,.katex .sizing.reset-size2.size8{font-size:2.4em}.katex .fontsize-ensurer.reset-size2.size9,.katex .sizing.reset-size2.size9{font-size:2.88em}.katex .fontsize-ensurer.reset-size2.size10,.katex .sizing.reset-size2.size10{font-size:3.4566666667em}.katex .fontsize-ensurer.reset-size2.size11,.katex .sizing.reset-size2.size11{font-size:4.1466666667em}.katex .fontsize-ensurer.reset-size3.size1,.katex .sizing.reset-size3.size1{font-size:.7142857143em}.katex .fontsize-ensurer.reset-size3.size2,.katex .sizing.reset-size3.size2{font-size:.8571428571em}.katex .fontsize-ensurer.reset-size3.size3,.katex .sizing.reset-size3.size3{font-size:1em}.katex .fontsize-ensurer.reset-size3.size4,.katex .sizing.reset-size3.size4{font-size:1.1428571429em}.katex .fontsize-ensurer.reset-size3.size5,.katex .sizing.reset-size3.size5{font-size:1.2857142857em}.katex .fontsize-ensurer.reset-size3.size6,.katex .sizing.reset-size3.size6{font-size:1.4285714286em}.katex .fontsize-ensurer.reset-size3.size7,.katex .sizing.reset-size3.size7{font-size:1.7142857143em}.katex .fontsize-ensurer.reset-size3.size8,.katex .sizing.reset-size3.size8{font-size:2.0571428571em}.katex .fontsize-ensurer.reset-size3.size9,.katex .sizing.reset-size3.size9{font-size:2.4685714286em}.katex .fontsize-ensurer.reset-size3.size10,.katex .sizing.reset-size3.size10{font-size:2.9628571429em}.katex .fontsize-ensurer.reset-size3.size11,.katex .sizing.reset-size3.size11{font-size:3.5542857143em}.katex .fontsize-ensurer.reset-size4.size1,.katex .sizing.reset-size4.size1{font-size:.625em}.katex .fontsize-ensurer.reset-size4.size2,.katex .sizing.reset-size4.size2{font-size:.75em}.katex .fontsize-ensurer.reset-size4.size3,.katex .sizing.reset-size4.size3{font-size:.875em}.katex .fontsize-ensurer.reset-size4.size4,.katex .sizing.reset-size4.size4{font-size:1em}.katex .fontsize-ensurer.reset-size4.size5,.katex .sizing.reset-size4.size5{font-size:1.125em}.katex .fontsize-ensurer.reset-size4.size6,.katex .sizing.reset-size4.size6{font-size:1.25em}.katex .fontsize-ensurer.reset-size4.size7,.katex .sizing.reset-size4.size7{font-size:1.5em}.katex .fontsize-ensurer.reset-size4.size8,.katex .sizing.reset-size4.size8{font-size:1.8em}.katex .fontsize-ensurer.reset-size4.size9,.katex .sizing.reset-size4.size9{font-size:2.16em}.katex .fontsize-ensurer.reset-size4.size10,.katex .sizing.reset-size4.size10{font-size:2.5925em}.katex .fontsize-ensurer.reset-size4.size11,.katex .sizing.reset-size4.size11{font-size:3.11em}.katex .fontsize-ensurer.reset-size5.size1,.katex .sizing.reset-size5.size1{font-size:.5555555556em}.katex .fontsize-ensurer.reset-size5.size2,.katex .sizing.reset-size5.size2{font-size:.6666666667em}.katex .fontsize-ensurer.reset-size5.size3,.katex .sizing.reset-size5.size3{font-size:.7777777778em}.katex .fontsize-ensurer.reset-size5.size4,.katex .sizing.reset-size5.size4{font-size:.8888888889em}.katex .fontsize-ensurer.reset-size5.size5,.katex .sizing.reset-size5.size5{font-size:1em}.katex .fontsize-ensurer.reset-size5.size6,.katex .sizing.reset-size5.size6{font-size:1.1111111111em}.katex .fontsize-ensurer.reset-size5.size7,.katex .sizing.reset-size5.size7{font-size:1.3333333333em}.katex .fontsize-ensurer.reset-size5.size8,.katex .sizing.reset-size5.size8{font-size:1.6em}.katex .fontsize-ensurer.reset-size5.size9,.katex .sizing.reset-size5.size9{font-size:1.92em}.katex .fontsize-ensurer.reset-size5.size10,.katex .sizing.reset-size5.size10{font-size:2.3044444444em}.katex .fontsize-ensurer.reset-size5.size11,.katex .sizing.reset-size5.size11{font-size:2.7644444444em}.katex .fontsize-ensurer.reset-size6.size1,.katex .sizing.reset-size6.size1{font-size:.5em}.katex .fontsize-ensurer.reset-size6.size2,.katex .sizing.reset-size6.size2{font-size:.6em}.katex .fontsize-ensurer.reset-size6.size3,.katex .sizing.reset-size6.size3{font-size:.7em}.katex .fontsize-ensurer.reset-size6.size4,.katex .sizing.reset-size6.size4{font-size:.8em}.katex .fontsize-ensurer.reset-size6.size5,.katex .sizing.reset-size6.size5{font-size:.9em}.katex .fontsize-ensurer.reset-size6.size6,.katex .sizing.reset-size6.size6{font-size:1em}.katex .fontsize-ensurer.reset-size6.size7,.katex .sizing.reset-size6.size7{font-size:1.2em}.katex .fontsize-ensurer.reset-size6.size8,.katex .sizing.reset-size6.size8{font-size:1.44em}.katex .fontsize-ensurer.reset-size6.size9,.katex .sizing.reset-size6.size9{font-size:1.728em}.katex .fontsize-ensurer.reset-size6.size10,.katex .sizing.reset-size6.size10{font-size:2.074em}.katex .fontsize-ensurer.reset-size6.size11,.katex .sizing.reset-size6.size11{font-size:2.488em}.katex .fontsize-ensurer.reset-size7.size1,.katex .sizing.reset-size7.size1{font-size:.4166666667em}.katex .fontsize-ensurer.reset-size7.size2,.katex .sizing.reset-size7.size2{font-size:.5em}.katex .fontsize-ensurer.reset-size7.size3,.katex .sizing.reset-size7.size3{font-size:.5833333333em}.katex .fontsize-ensurer.reset-size7.size4,.katex .sizing.reset-size7.size4{font-size:.6666666667em}.katex .fontsize-ensurer.reset-size7.size5,.katex .sizing.reset-size7.size5{font-size:.75em}.katex .fontsize-ensurer.reset-size7.size6,.katex .sizing.reset-size7.size6{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size7.size7,.katex .sizing.reset-size7.size7{font-size:1em}.katex .fontsize-ensurer.reset-size7.size8,.katex .sizing.reset-size7.size8{font-size:1.2em}.katex .fontsize-ensurer.reset-size7.size9,.katex .sizing.reset-size7.size9{font-size:1.44em}.katex .fontsize-ensurer.reset-size7.size10,.katex .sizing.reset-size7.size10{font-size:1.7283333333em}.katex .fontsize-ensurer.reset-size7.size11,.katex .sizing.reset-size7.size11{font-size:2.0733333333em}.katex .fontsize-ensurer.reset-size8.size1,.katex .sizing.reset-size8.size1{font-size:.3472222222em}.katex .fontsize-ensurer.reset-size8.size2,.katex .sizing.reset-size8.size2{font-size:.4166666667em}.katex .fontsize-ensurer.reset-size8.size3,.katex .sizing.reset-size8.size3{font-size:.4861111111em}.katex .fontsize-ensurer.reset-size8.size4,.katex .sizing.reset-size8.size4{font-size:.5555555556em}.katex .fontsize-ensurer.reset-size8.size5,.katex .sizing.reset-size8.size5{font-size:.625em}.katex .fontsize-ensurer.reset-size8.size6,.katex .sizing.reset-size8.size6{font-size:.6944444444em}.katex .fontsize-ensurer.reset-size8.size7,.katex .sizing.reset-size8.size7{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size8.size8,.katex .sizing.reset-size8.size8{font-size:1em}.katex .fontsize-ensurer.reset-size8.size9,.katex .sizing.reset-size8.size9{font-size:1.2em}.katex .fontsize-ensurer.reset-size8.size10,.katex .sizing.reset-size8.size10{font-size:1.4402777778em}.katex .fontsize-ensurer.reset-size8.size11,.katex .sizing.reset-size8.size11{font-size:1.7277777778em}.katex .fontsize-ensurer.reset-size9.size1,.katex .sizing.reset-size9.size1{font-size:.2893518519em}.katex .fontsize-ensurer.reset-size9.size2,.katex .sizing.reset-size9.size2{font-size:.3472222222em}.katex .fontsize-ensurer.reset-size9.size3,.katex .sizing.reset-size9.size3{font-size:.4050925926em}.katex .fontsize-ensurer.reset-size9.size4,.katex .sizing.reset-size9.size4{font-size:.462962963em}.katex .fontsize-ensurer.reset-size9.size5,.katex .sizing.reset-size9.size5{font-size:.5208333333em}.katex .fontsize-ensurer.reset-size9.size6,.katex .sizing.reset-size9.size6{font-size:.5787037037em}.katex .fontsize-ensurer.reset-size9.size7,.katex .sizing.reset-size9.size7{font-size:.6944444444em}.katex .fontsize-ensurer.reset-size9.size8,.katex .sizing.reset-size9.size8{font-size:.8333333333em}.katex .fontsize-ensurer.reset-size9.size9,.katex .sizing.reset-size9.size9{font-size:1em}.katex .fontsize-ensurer.reset-size9.size10,.katex .sizing.reset-size9.size10{font-size:1.2002314815em}.katex .fontsize-ensurer.reset-size9.size11,.katex .sizing.reset-size9.size11{font-size:1.4398148148em}.katex .fontsize-ensurer.reset-size10.size1,.katex .sizing.reset-size10.size1{font-size:.2410800386em}.katex .fontsize-ensurer.reset-size10.size2,.katex .sizing.reset-size10.size2{font-size:.2892960463em}.katex .fontsize-ensurer.reset-size10.size3,.katex .sizing.reset-size10.size3{font-size:.337512054em}.katex .fontsize-ensurer.reset-size10.size4,.katex .sizing.reset-size10.size4{font-size:.3857280617em}.katex .fontsize-ensurer.reset-size10.size5,.katex .sizing.reset-size10.size5{font-size:.4339440694em}.katex .fontsize-ensurer.reset-size10.size6,.katex .sizing.reset-size10.size6{font-size:.4821600771em}.katex .fontsize-ensurer.reset-size10.size7,.katex .sizing.reset-size10.size7{font-size:.5785920926em}.katex .fontsize-ensurer.reset-size10.size8,.katex .sizing.reset-size10.size8{font-size:.6943105111em}.katex .fontsize-ensurer.reset-size10.size9,.katex .sizing.reset-size10.size9{font-size:.8331726133em}.katex .fontsize-ensurer.reset-size10.size10,.katex .sizing.reset-size10.size10{font-size:1em}.katex .fontsize-ensurer.reset-size10.size11,.katex .sizing.reset-size10.size11{font-size:1.1996142719em}.katex .fontsize-ensurer.reset-size11.size1,.katex .sizing.reset-size11.size1{font-size:.2009646302em}.katex .fontsize-ensurer.reset-size11.size2,.katex .sizing.reset-size11.size2{font-size:.2411575563em}.katex .fontsize-ensurer.reset-size11.size3,.katex .sizing.reset-size11.size3{font-size:.2813504823em}.katex .fontsize-ensurer.reset-size11.size4,.katex .sizing.reset-size11.size4{font-size:.3215434084em}.katex .fontsize-ensurer.reset-size11.size5,.katex .sizing.reset-size11.size5{font-size:.3617363344em}.katex .fontsize-ensurer.reset-size11.size6,.katex .sizing.reset-size11.size6{font-size:.4019292605em}.katex .fontsize-ensurer.reset-size11.size7,.katex .sizing.reset-size11.size7{font-size:.4823151125em}.katex .fontsize-ensurer.reset-size11.size8,.katex .sizing.reset-size11.size8{font-size:.578778135em}.katex .fontsize-ensurer.reset-size11.size9,.katex .sizing.reset-size11.size9{font-size:.6945337621em}.katex .fontsize-ensurer.reset-size11.size10,.katex .sizing.reset-size11.size10{font-size:.8336012862em}.katex .fontsize-ensurer.reset-size11.size11,.katex .sizing.reset-size11.size11{font-size:1em}.katex .delimsizing.size1{font-family:KaTeX_Size1}.katex .delimsizing.size2{font-family:KaTeX_Size2}.katex .delimsizing.size3{font-family:KaTeX_Size3}.katex .delimsizing.size4{font-family:KaTeX_Size4}.katex .delimsizing.mult .delim-size1>span{font-family:KaTeX_Size1}.katex .delimsizing.mult .delim-size4>span{font-family:KaTeX_Size4}.katex .nulldelimiter{display:inline-block;width:.12em}.katex .delimcenter,.katex .op-symbol{position:relative}.katex .op-symbol.small-op{font-family:KaTeX_Size1}.katex .op-symbol.large-op{font-family:KaTeX_Size2}.katex .accent>.vlist-t,.katex .op-limits>.vlist-t{text-align:center}.katex .accent .accent-body{position:relative}.katex .accent .accent-body:not(.accent-full){width:0}.katex .overlay{display:block}.katex .mtable .vertical-separator{display:inline-block;min-width:1px}.katex .mtable .arraycolsep{display:inline-block}.katex .mtable .col-align-c>.vlist-t{text-align:center}.katex .mtable .col-align-l>.vlist-t{text-align:left}.katex .mtable .col-align-r>.vlist-t{text-align:right}.katex .svg-align{text-align:left}.katex svg{fill:currentColor;stroke:currentColor;fill-rule:nonzero;fill-opacity:1;stroke-width:1;stroke-linecap:butt;stroke-linejoin:miter;stroke-miterlimit:4;stroke-dasharray:none;stroke-dashoffset:0;stroke-opacity:1;display:block;height:inherit;position:absolute;width:100%}.katex svg path{stroke:none}.katex img{border-style:none;max-height:none;max-width:none;min-height:0;min-width:0}.katex .stretchy{display:block;overflow:hidden;position:relative;width:100%}.katex .stretchy:after,.katex .stretchy:before{content:""}.katex .hide-tail{overflow:hidden;position:relative;width:100%}.katex .halfarrow-left{left:0;overflow:hidden;position:absolute;width:50.2%}.katex .halfarrow-right{overflow:hidden;position:absolute;right:0;width:50.2%}.katex .brace-left{left:0;overflow:hidden;position:absolute;width:25.1%}.katex .brace-center{left:25%;overflow:hidden;position:absolute;width:50%}.katex .brace-right{overflow:hidden;position:absolute;right:0;width:25.1%}.katex .x-arrow-pad{padding:0 .5em}.katex .cd-arrow-pad{padding:0 .55556em 0 .27778em}.katex .mover,.katex .munder,.katex .x-arrow{text-align:center}.katex .boxpad{padding:0 .3em}.katex .fbox,.katex .fcolorbox{border:.04em solid;box-sizing:border-box}.katex .cancel-pad{padding:0 .2em}.katex .cancel-lap{margin-left:-.2em;margin-right:-.2em}.katex .sout{border-bottom-style:solid;border-bottom-width:.08em}.katex .angl{border-right:.049em solid;border-top:.049em solid;box-sizing:border-box;margin-right:.03889em}.katex .anglpad{padding:0 .03889em}.katex .eqn-num:before{content:"(" counter(katexEqnNo) ")";counter-increment:katexEqnNo}.katex .mml-eqn-num:before{content:"(" counter(mmlEqnNo) ")";counter-increment:mmlEqnNo}.katex .mtr-glue{width:50%}.katex .cd-vert-arrow{display:inline-block;position:relative}.katex .cd-label-left{display:inline-block;position:absolute;right:calc(50% + .3em);text-align:left}.katex .cd-label-right{display:inline-block;left:calc(50% + .3em);position:absolute;text-align:right}.katex-display{display:block;margin:1em 0;text-align:center}.katex-display>.katex{display:block;text-align:center;white-space:nowrap}.katex-display>.katex>.katex-html{display:block;position:relative}.katex-display>.katex>.katex-html>.tag{position:absolute;right:0}.katex-display.leqno>.katex>.katex-html>.tag{left:0;right:auto}.katex-display.fleqn>.katex{padding-left:2em;text-align:left}body{counter-reset:katexEqnNo mmlEqnNo}
diff --git a/reader/vendor/katex.min.js b/reader/vendor/katex.min.js
new file mode 100644
index 0000000..f59062a
--- /dev/null
+++ b/reader/vendor/katex.min.js
@@ -0,0 +1 @@
+!function(e,t){"object"==typeof exports&&"object"==typeof module?module.exports=t():"function"==typeof define&&define.amd?define([],t):"object"==typeof exports?exports.katex=t():e.katex=t()}("undefined"!=typeof self?self:this,(function(){return function(){"use strict";var e={d:function(t,r){for(var n in r)e.o(r,n)&&!e.o(t,n)&&Object.defineProperty(t,n,{enumerable:!0,get:r[n]})},o:function(e,t){return Object.prototype.hasOwnProperty.call(e,t)}},t={};e.d(t,{default:function(){return Wn}});class r{constructor(e,t){this.name=void 0,this.position=void 0,this.length=void 0,this.rawMessage=void 0;let n,o,s="KaTeX parse error: "+e;const i=t&&t.loc;if(i&&i.start<=i.end){const e=i.lexer.input;n=i.start,o=i.end,n===e.length?s+=" at end of input: ":s+=" at position "+(n+1)+": ";const t=e.slice(n,o).replace(/[^]/g,"$&\u0332");let r,a;r=n>15?"\u2026"+e.slice(n-15,n):e.slice(0,n),a=o+15<e.length?e.slice(o,o+15)+"\u2026":e.slice(o),s+=r+t+a}const a=new Error(s);return a.name="ParseError",a.__proto__=r.prototype,a.position=n,null!=n&&null!=o&&(a.length=o-n),a.rawMessage=e,a}}r.prototype.__proto__=Error.prototype;var n=r;const o=/([A-Z])/g,s={"&":"&amp;",">":"&gt;","<":"&lt;",'"':"&quot;","'":"&#x27;"},i=/[&><"']/g;const a=function(e){return"ordgroup"===e.type||"color"===e.type?1===e.body.length?a(e.body[0]):e:"font"===e.type?a(e.body):e};var l={contains:function(e,t){return-1!==e.indexOf(t)},deflt:function(e,t){return void 0===e?t:e},escape:function(e){return String(e).replace(i,(e=>s[e]))},hyphenate:function(e){return e.replace(o,"-$1").toLowerCase()},getBaseElem:a,isCharacterBox:function(e){const t=a(e);return"mathord"===t.type||"textord"===t.type||"atom"===t.type},protocolFromUrl:function(e){const t=/^[\x00-\x20]*([^\\/#?]*?)(:|&#0*58|&#x0*3a|&colon)/i.exec(e);return t?":"!==t[2]?null:/^[a-zA-Z][a-zA-Z0-9+\-.]*$/.test(t[1])?t[1].toLowerCase():null:"_relative"}};const h={displayMode:{type:"boolean",description:"Render math in display mode, which puts the math in display style (so \\int and \\sum are large, for example), and centers the math on the page on its own line.",cli:"-d, --display-mode"},output:{type:{enum:["htmlAndMathml","html","mathml"]},description:"Determines the markup language of the output.",cli:"-F, --format <type>"},leqno:{type:"boolean",description:"Render display math in leqno style (left-justified tags)."},fleqn:{type:"boolean",description:"Render display math flush left."},throwOnError:{type:"boolean",default:!0,cli:"-t, --no-throw-on-error",cliDescription:"Render errors (in the color given by --error-color) instead of throwing a ParseError exception when encountering an error."},errorColor:{type:"string",default:"#cc0000",cli:"-c, --error-color <color>",cliDescription:"A color string given in the format 'rgb' or 'rrggbb' (no #). This option determines the color of errors rendered by the -t option.",cliProcessor:e=>"#"+e},macros:{type:"object",cli:"-m, --macro <def>",cliDescription:"Define custom macro of the form '\\foo:expansion' (use multiple -m arguments for multiple macros).",cliDefault:[],cliProcessor:(e,t)=>(t.push(e),t)},minRuleThickness:{type:"number",description:"Specifies a minimum thickness, in ems, for fraction lines, `\\sqrt` top lines, `{array}` vertical lines, `\\hline`, `\\hdashline`, `\\underline`, `\\overline`, and the borders of `\\fbox`, `\\boxed`, and `\\fcolorbox`.",processor:e=>Math.max(0,e),cli:"--min-rule-thickness <size>",cliProcessor:parseFloat},colorIsTextColor:{type:"boolean",description:"Makes \\color behave like LaTeX's 2-argument \\textcolor, instead of LaTeX's one-argument \\color mode change.",cli:"-b, --color-is-text-color"},strict:{type:[{enum:["warn","ignore","error"]},"boolean","function"],description:"Turn on strict / LaTeX faithfulness mode, which throws an error if the input uses features that are not supported by LaTeX.",cli:"-S, --strict",cliDefault:!1},trust:{type:["boolean","function"],description:"Trust the input, enabling all HTML features such as \\url.",cli:"-T, --trust"},maxSize:{type:"number",default:1/0,description:"If non-zero, all user-specified sizes, e.g. in \\rule{500em}{500em}, will be capped to maxSize ems. Otherwise, elements and spaces can be arbitrarily large",processor:e=>Math.max(0,e),cli:"-s, --max-size <n>",cliProcessor:parseInt},maxExpand:{type:"number",default:1e3,description:"Limit the number of macro expansions to the specified number, to prevent e.g. infinite macro loops. If set to Infinity, the macro expander will try to fully expand as in LaTeX.",processor:e=>Math.max(0,e),cli:"-e, --max-expand <n>",cliProcessor:e=>"Infinity"===e?1/0:parseInt(e)},globalGroup:{type:"boolean",cli:!1}};function c(e){if(e.default)return e.default;const t=e.type,r=Array.isArray(t)?t[0]:t;if("string"!=typeof r)return r.enum[0];switch(r){case"boolean":return!1;case"string":return"";case"number":return 0;case"object":return{}}}class m{constructor(e){this.displayMode=void 0,this.output=void 0,this.leqno=void 0,this.fleqn=void 0,this.throwOnError=void 0,this.errorColor=void 0,this.macros=void 0,this.minRuleThickness=void 0,this.colorIsTextColor=void 0,this.strict=void 0,this.trust=void 0,this.maxSize=void 0,this.maxExpand=void 0,this.globalGroup=void 0,e=e||{};for(const t in h)if(h.hasOwnProperty(t)){const r=h[t];this[t]=void 0!==e[t]?r.processor?r.processor(e[t]):e[t]:c(r)}}reportNonstrict(e,t,r){let o=this.strict;if("function"==typeof o&&(o=o(e,t,r)),o&&"ignore"!==o){if(!0===o||"error"===o)throw new n("LaTeX-incompatible input and strict mode is set to 'error': "+t+" ["+e+"]",r);"warn"===o?"undefined"!=typeof console&&console.warn("LaTeX-incompatible input and strict mode is set to 'warn': "+t+" ["+e+"]"):"undefined"!=typeof console&&console.warn("LaTeX-incompatible input and strict mode is set to unrecognized '"+o+"': "+t+" ["+e+"]")}}useStrictBehavior(e,t,r){let n=this.strict;if("function"==typeof n)try{n=n(e,t,r)}catch(e){n="error"}return!(!n||"ignore"===n)&&(!0===n||"error"===n||("warn"===n?("undefined"!=typeof console&&console.warn("LaTeX-incompatible input and strict mode is set to 'warn': "+t+" ["+e+"]"),!1):("undefined"!=typeof console&&console.warn("LaTeX-incompatible input and strict mode is set to unrecognized '"+n+"': "+t+" ["+e+"]"),!1)))}isTrusted(e){if(e.url&&!e.protocol){const t=l.protocolFromUrl(e.url);if(null==t)return!1;e.protocol=t}const t="function"==typeof this.trust?this.trust(e):this.trust;return Boolean(t)}}class p{constructor(e,t,r){this.id=void 0,this.size=void 0,this.cramped=void 0,this.id=e,this.size=t,this.cramped=r}sup(){return u[d[this.id]]}sub(){return u[g[this.id]]}fracNum(){return u[f[this.id]]}fracDen(){return u[b[this.id]]}cramp(){return u[y[this.id]]}text(){return u[x[this.id]]}isTight(){return this.size>=2}}const u=[new p(0,0,!1),new p(1,0,!0),new p(2,1,!1),new p(3,1,!0),new p(4,2,!1),new p(5,2,!0),new p(6,3,!1),new p(7,3,!0)],d=[4,5,4,5,6,7,6,7],g=[5,5,5,5,7,7,7,7],f=[2,3,4,5,6,7,6,7],b=[3,3,5,5,7,7,7,7],y=[1,1,3,3,5,5,7,7],x=[0,1,2,3,2,3,2,3];var w={DISPLAY:u[0],TEXT:u[2],SCRIPT:u[4],SCRIPTSCRIPT:u[6]};const v=[{name:"latin",blocks:[[256,591],[768,879]]},{name:"cyrillic",blocks:[[1024,1279]]},{name:"armenian",blocks:[[1328,1423]]},{name:"brahmic",blocks:[[2304,4255]]},{name:"georgian",blocks:[[4256,4351]]},{name:"cjk",blocks:[[12288,12543],[19968,40879],[65280,65376]]},{name:"hangul",blocks:[[44032,55215]]}];const k=[];function S(e){for(let t=0;t<k.length;t+=2)if(e>=k[t]&&e<=k[t+1])return!0;return!1}v.forEach((e=>e.blocks.forEach((e=>k.push(...e)))));const M=80,z={doubleleftarrow:"M262 157\nl10-10c34-36 62.7-77 86-123 3.3-8 5-13.3 5-16 0-5.3-6.7-8-20-8-7.3\n 0-12.2.5-14.5 1.5-2.3 1-4.8 4.5-7.5 10.5-49.3 97.3-121.7 169.3-217 216-28\n 14-57.3 25-88 33-6.7 2-11 3.8-13 5.5-2 1.7-3 4.2-3 7.5s1 5.8 3 7.5\nc2 1.7 6.3 3.5 13 5.5 68 17.3 128.2 47.8 180.5 91.5 52.3 43.7 93.8 96.2 124.5\n 157.5 9.3 8 15.3 12.3 18 13h6c12-.7 18-4 18-10 0-2-1.7-7-5-15-23.3-46-52-87\n-86-123l-10-10h399738v-40H218c328 0 0 0 0 0l-10-8c-26.7-20-65.7-43-117-69 2.7\n-2 6-3.7 10-5 36.7-16 72.3-37.3 107-64l10-8h399782v-40z\nm8 0v40h399730v-40zm0 194v40h399730v-40z",doublerightarrow:"M399738 392l\n-10 10c-34 36-62.7 77-86 123-3.3 8-5 13.3-5 16 0 5.3 6.7 8 20 8 7.3 0 12.2-.5\n 14.5-1.5 2.3-1 4.8-4.5 7.5-10.5 49.3-97.3 121.7-169.3 217-216 28-14 57.3-25 88\n-33 6.7-2 11-3.8 13-5.5 2-1.7 3-4.2 3-7.5s-1-5.8-3-7.5c-2-1.7-6.3-3.5-13-5.5-68\n-17.3-128.2-47.8-180.5-91.5-52.3-43.7-93.8-96.2-124.5-157.5-9.3-8-15.3-12.3-18\n-13h-6c-12 .7-18 4-18 10 0 2 1.7 7 5 15 23.3 46 52 87 86 123l10 10H0v40h399782\nc-328 0 0 0 0 0l10 8c26.7 20 65.7 43 117 69-2.7 2-6 3.7-10 5-36.7 16-72.3 37.3\n-107 64l-10 8H0v40zM0 157v40h399730v-40zm0 194v40h399730v-40z",leftarrow:"M400000 241H110l3-3c68.7-52.7 113.7-120\n 135-202 4-14.7 6-23 6-25 0-7.3-7-11-21-11-8 0-13.2.8-15.5 2.5-2.3 1.7-4.2 5.8\n-5.5 12.5-1.3 4.7-2.7 10.3-4 17-12 48.7-34.8 92-68.5 130S65.3 228.3 18 247\nc-10 4-16 7.7-18 11 0 8.7 6 14.3 18 17 47.3 18.7 87.8 47 121.5 85S196 441.3 208\n 490c.7 2 1.3 5 2 9s1.2 6.7 1.5 8c.3 1.3 1 3.3 2 6s2.2 4.5 3.5 5.5c1.3 1 3.3\n 1.8 6 2.5s6 1 10 1c14 0 21-3.7 21-11 0-2-2-10.3-6-25-20-79.3-65-146.7-135-202\n l-3-3h399890zM100 241v40h399900v-40z",leftbrace:"M6 548l-6-6v-35l6-11c56-104 135.3-181.3 238-232 57.3-28.7 117\n-45 179-50h399577v120H403c-43.3 7-81 15-113 26-100.7 33-179.7 91-237 174-2.7\n 5-6 9-10 13-.7 1-7.3 1-20 1H6z",leftbraceunder:"M0 6l6-6h17c12.688 0 19.313.3 20 1 4 4 7.313 8.3 10 13\n 35.313 51.3 80.813 93.8 136.5 127.5 55.688 33.7 117.188 55.8 184.5 66.5.688\n 0 2 .3 4 1 18.688 2.7 76 4.3 172 5h399450v120H429l-6-1c-124.688-8-235-61.7\n-331-161C60.687 138.7 32.312 99.3 7 54L0 41V6z",leftgroup:"M400000 80\nH435C64 80 168.3 229.4 21 260c-5.9 1.2-18 0-18 0-2 0-3-1-3-3v-38C76 61 257 0\n 435 0h399565z",leftgroupunder:"M400000 262\nH435C64 262 168.3 112.6 21 82c-5.9-1.2-18 0-18 0-2 0-3 1-3 3v38c76 158 257 219\n 435 219h399565z",leftharpoon:"M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3\n-3.3 10.2-9.5 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5\n-18.3 3-21-1.3-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7\n-196 228-6.7 4.7-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40z",leftharpoonplus:"M0 267c.7 5.3 3 10 7 14h399993v-40H93c3.3-3.3 10.2-9.5\n 20.5-18.5s17.8-15.8 22.5-20.5c50.7-52 88-110.3 112-175 4-11.3 5-18.3 3-21-1.3\n-4-7.3-6-18-6-8 0-13 .7-15 2s-4.7 6.7-8 16c-42 98.7-107.3 174.7-196 228-6.7 4.7\n-10.7 8-12 10-1.3 2-2 5.7-2 11zm100-26v40h399900v-40zM0 435v40h400000v-40z\nm0 0v40h400000v-40z",leftharpoondown:"M7 241c-4 4-6.333 8.667-7 14 0 5.333.667 9 2 11s5.333\n 5.333 12 10c90.667 54 156 130 196 228 3.333 10.667 6.333 16.333 9 17 2 .667 5\n 1 9 1h5c10.667 0 16.667-2 18-6 2-2.667 1-9.667-3-21-32-87.333-82.667-157.667\n-152-211l-3-3h399907v-40zM93 281 H400000 v-40L7 241z",leftharpoondownplus:"M7 435c-4 4-6.3 8.7-7 14 0 5.3.7 9 2 11s5.3 5.3 12\n 10c90.7 54 156 130 196 228 3.3 10.7 6.3 16.3 9 17 2 .7 5 1 9 1h5c10.7 0 16.7\n-2 18-6 2-2.7 1-9.7-3-21-32-87.3-82.7-157.7-152-211l-3-3h399907v-40H7zm93 0\nv40h399900v-40zM0 241v40h399900v-40zm0 0v40h399900v-40z",lefthook:"M400000 281 H103s-33-11.2-61-33.5S0 197.3 0 164s14.2-61.2 42.5\n-83.5C70.8 58.2 104 47 142 47 c16.7 0 25 6.7 25 20 0 12-8.7 18.7-26 20-40 3.3\n-68.7 15.7-86 37-10 12-15 25.3-15 40 0 22.7 9.8 40.7 29.5 54 19.7 13.3 43.5 21\n 71.5 23h399859zM103 281v-40h399897v40z",leftlinesegment:"M40 281 V428 H0 V94 H40 V241 H400000 v40z\nM40 281 V428 H0 V94 H40 V241 H400000 v40z",leftmapsto:"M40 281 V448H0V74H40V241H400000v40z\nM40 281 V448H0V74H40V241H400000v40z",leftToFrom:"M0 147h400000v40H0zm0 214c68 40 115.7 95.7 143 167h22c15.3 0 23\n-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69-70-101l-7-8h399905v-40H95l7-8\nc28.7-32 52-65.7 70-101 10.7-23.3 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 265.3\n 68 321 0 361zm0-174v-40h399900v40zm100 154v40h399900v-40z",longequal:"M0 50 h400000 v40H0z m0 194h40000v40H0z\nM0 50 h400000 v40H0z m0 194h40000v40H0z",midbrace:"M200428 334\nc-100.7-8.3-195.3-44-280-108-55.3-42-101.7-93-139-153l-9-14c-2.7 4-5.7 8.7-9 14\n-53.3 86.7-123.7 153-211 199-66.7 36-137.3 56.3-212 62H0V214h199568c178.3-11.7\n 311.7-78.3 403-201 6-8 9.7-12 11-12 .7-.7 6.7-1 18-1s17.3.3 18 1c1.3 0 5 4 11\n 12 44.7 59.3 101.3 106.3 170 141s145.3 54.3 229 60h199572v120z",midbraceunder:"M199572 214\nc100.7 8.3 195.3 44 280 108 55.3 42 101.7 93 139 153l9 14c2.7-4 5.7-8.7 9-14\n 53.3-86.7 123.7-153 211-199 66.7-36 137.3-56.3 212-62h199568v120H200432c-178.3\n 11.7-311.7 78.3-403 201-6 8-9.7 12-11 12-.7.7-6.7 1-18 1s-17.3-.3-18-1c-1.3 0\n-5-4-11-12-44.7-59.3-101.3-106.3-170-141s-145.3-54.3-229-60H0V214z",oiintSize1:"M512.6 71.6c272.6 0 320.3 106.8 320.3 178.2 0 70.8-47.7 177.6\n-320.3 177.6S193.1 320.6 193.1 249.8c0-71.4 46.9-178.2 319.5-178.2z\nm368.1 178.2c0-86.4-60.9-215.4-368.1-215.4-306.4 0-367.3 129-367.3 215.4 0 85.8\n60.9 214.8 367.3 214.8 307.2 0 368.1-129 368.1-214.8z",oiintSize2:"M757.8 100.1c384.7 0 451.1 137.6 451.1 230 0 91.3-66.4 228.8\n-451.1 228.8-386.3 0-452.7-137.5-452.7-228.8 0-92.4 66.4-230 452.7-230z\nm502.4 230c0-111.2-82.4-277.2-502.4-277.2s-504 166-504 277.2\nc0 110 84 276 504 276s502.4-166 502.4-276z",oiiintSize1:"M681.4 71.6c408.9 0 480.5 106.8 480.5 178.2 0 70.8-71.6 177.6\n-480.5 177.6S202.1 320.6 202.1 249.8c0-71.4 70.5-178.2 479.3-178.2z\nm525.8 178.2c0-86.4-86.8-215.4-525.7-215.4-437.9 0-524.7 129-524.7 215.4 0\n85.8 86.8 214.8 524.7 214.8 438.9 0 525.7-129 525.7-214.8z",oiiintSize2:"M1021.2 53c603.6 0 707.8 165.8 707.8 277.2 0 110-104.2 275.8\n-707.8 275.8-606 0-710.2-165.8-710.2-275.8C311 218.8 415.2 53 1021.2 53z\nm770.4 277.1c0-131.2-126.4-327.6-770.5-327.6S248.4 198.9 248.4 330.1\nc0 130 128.8 326.4 772.7 326.4s770.5-196.4 770.5-326.4z",rightarrow:"M0 241v40h399891c-47.3 35.3-84 78-110 128\n-16.7 32-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20\n 11 8 0 13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7\n 39-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85\n-40.5-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5\n-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67\n 151.7 139 205zm0 0v40h399900v-40z",rightbrace:"M400000 542l\n-6 6h-17c-12.7 0-19.3-.3-20-1-4-4-7.3-8.3-10-13-35.3-51.3-80.8-93.8-136.5-127.5\ns-117.2-55.8-184.5-66.5c-.7 0-2-.3-4-1-18.7-2.7-76-4.3-172-5H0V214h399571l6 1\nc124.7 8 235 61.7 331 161 31.3 33.3 59.7 72.7 85 118l7 13v35z",rightbraceunder:"M399994 0l6 6v35l-6 11c-56 104-135.3 181.3-238 232-57.3\n 28.7-117 45-179 50H-300V214h399897c43.3-7 81-15 113-26 100.7-33 179.7-91 237\n-174 2.7-5 6-9 10-13 .7-1 7.3-1 20-1h17z",rightgroup:"M0 80h399565c371 0 266.7 149.4 414 180 5.9 1.2 18 0 18 0 2 0\n 3-1 3-3v-38c-76-158-257-219-435-219H0z",rightgroupunder:"M0 262h399565c371 0 266.7-149.4 414-180 5.9-1.2 18 0 18\n 0 2 0 3 1 3 3v38c-76 158-257 219-435 219H0z",rightharpoon:"M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3\n-3.7-15.3-11-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2\n-10.7 0-16.7 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58\n 69.2 92 94.5zm0 0v40h399900v-40z",rightharpoonplus:"M0 241v40h399993c4.7-4.7 7-9.3 7-14 0-9.3-3.7-15.3-11\n-18-92.7-56.7-159-133.7-199-231-3.3-9.3-6-14.7-8-16-2-1.3-7-2-15-2-10.7 0-16.7\n 2-18 6-2 2.7-1 9.7 3 21 15.3 42 36.7 81.8 64 119.5 27.3 37.7 58 69.2 92 94.5z\nm0 0v40h399900v-40z m100 194v40h399900v-40zm0 0v40h399900v-40z",rightharpoondown:"M399747 511c0 7.3 6.7 11 20 11 8 0 13-.8 15-2.5s4.7-6.8\n 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3 8.5-5.8 9.5\n-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3-64.7 57-92 95\n-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 241v40h399900v-40z",rightharpoondownplus:"M399747 705c0 7.3 6.7 11 20 11 8 0 13-.8\n 15-2.5s4.7-6.8 8-15.5c40-94 99.3-166.3 178-217 13.3-8 20.3-12.3 21-13 5.3-3.3\n 8.5-5.8 9.5-7.5 1-1.7 1.5-5.2 1.5-10.5s-2.3-10.3-7-15H0v40h399908c-34 25.3\n-64.7 57-92 95-27.3 38-48.7 77.7-64 119-3.3 8.7-5 14-5 16zM0 435v40h399900v-40z\nm0-194v40h400000v-40zm0 0v40h400000v-40z",righthook:"M399859 241c-764 0 0 0 0 0 40-3.3 68.7-15.7 86-37 10-12 15-25.3\n 15-40 0-22.7-9.8-40.7-29.5-54-19.7-13.3-43.5-21-71.5-23-17.3-1.3-26-8-26-20 0\n-13.3 8.7-20 26-20 38 0 71 11.2 99 33.5 0 0 7 5.6 21 16.7 14 11.2 21 33.5 21\n 66.8s-14 61.2-42 83.5c-28 22.3-61 33.5-99 33.5L0 241z M0 281v-40h399859v40z",rightlinesegment:"M399960 241 V94 h40 V428 h-40 V281 H0 v-40z\nM399960 241 V94 h40 V428 h-40 V281 H0 v-40z",rightToFrom:"M400000 167c-70.7-42-118-97.7-142-167h-23c-15.3 0-23 .3-23\n 1 0 1.3 5.3 13.7 16 37 18 35.3 41.3 69 70 101l7 8H0v40h399905l-7 8c-28.7 32\n-52 65.7-70 101-10.7 23.3-16 35.7-16 37 0 .7 7.7 1 23 1h23c24-69.3 71.3-125 142\n-167z M100 147v40h399900v-40zM0 341v40h399900v-40z",twoheadleftarrow:"M0 167c68 40\n 115.7 95.7 143 167h22c15.3 0 23-.3 23-1 0-1.3-5.3-13.7-16-37-18-35.3-41.3-69\n-70-101l-7-8h125l9 7c50.7 39.3 85 86 103 140h46c0-4.7-6.3-18.7-19-42-18-35.3\n-40-67.3-66-96l-9-9h399716v-40H284l9-9c26-28.7 48-60.7 66-96 12.7-23.333 19\n-37.333 19-42h-46c-18 54-52.3 100.7-103 140l-9 7H95l7-8c28.7-32 52-65.7 70-101\n 10.7-23.333 16-35.7 16-37 0-.7-7.7-1-23-1h-22C115.7 71.3 68 127 0 167z",twoheadrightarrow:"M400000 167\nc-68-40-115.7-95.7-143-167h-22c-15.3 0-23 .3-23 1 0 1.3 5.3 13.7 16 37 18 35.3\n 41.3 69 70 101l7 8h-125l-9-7c-50.7-39.3-85-86-103-140h-46c0 4.7 6.3 18.7 19 42\n 18 35.3 40 67.3 66 96l9 9H0v40h399716l-9 9c-26 28.7-48 60.7-66 96-12.7 23.333\n-19 37.333-19 42h46c18-54 52.3-100.7 103-140l9-7h125l-7 8c-28.7 32-52 65.7-70\n 101-10.7 23.333-16 35.7-16 37 0 .7 7.7 1 23 1h22c27.3-71.3 75-127 143-167z",tilde1:"M200 55.538c-77 0-168 73.953-177 73.953-3 0-7\n-2.175-9-5.437L2 97c-1-2-2-4-2-6 0-4 2-7 5-9l20-12C116 12 171 0 207 0c86 0\n 114 68 191 68 78 0 168-68 177-68 4 0 7 2 9 5l12 19c1 2.175 2 4.35 2 6.525 0\n 4.35-2 7.613-5 9.788l-19 13.05c-92 63.077-116.937 75.308-183 76.128\n-68.267.847-113-73.952-191-73.952z",tilde2:"M344 55.266c-142 0-300.638 81.316-311.5 86.418\n-8.01 3.762-22.5 10.91-23.5 5.562L1 120c-1-2-1-3-1-4 0-5 3-9 8-10l18.4-9C160.9\n 31.9 283 0 358 0c148 0 188 122 331 122s314-97 326-97c4 0 8 2 10 7l7 21.114\nc1 2.14 1 3.21 1 4.28 0 5.347-3 9.626-7 10.696l-22.3 12.622C852.6 158.372 751\n 181.476 676 181.476c-149 0-189-126.21-332-126.21z",tilde3:"M786 59C457 59 32 175.242 13 175.242c-6 0-10-3.457\n-11-10.37L.15 138c-1-7 3-12 10-13l19.2-6.4C378.4 40.7 634.3 0 804.3 0c337 0\n 411.8 157 746.8 157 328 0 754-112 773-112 5 0 10 3 11 9l1 14.075c1 8.066-.697\n 16.595-6.697 17.492l-21.052 7.31c-367.9 98.146-609.15 122.696-778.15 122.696\n -338 0-409-156.573-744-156.573z",tilde4:"M786 58C457 58 32 177.487 13 177.487c-6 0-10-3.345\n-11-10.035L.15 143c-1-7 3-12 10-13l22-6.7C381.2 35 637.15 0 807.15 0c337 0 409\n 177 744 177 328 0 754-127 773-127 5 0 10 3 11 9l1 14.794c1 7.805-3 13.38-9\n 14.495l-20.7 5.574c-366.85 99.79-607.3 139.372-776.3 139.372-338 0-409\n -175.236-744-175.236z",vec:"M377 20c0-5.333 1.833-10 5.5-14S391 0 397 0c4.667 0 8.667 1.667 12 5\n3.333 2.667 6.667 9 10 19 6.667 24.667 20.333 43.667 41 57 7.333 4.667 11\n10.667 11 18 0 6-1 10-3 12s-6.667 5-14 9c-28.667 14.667-53.667 35.667-75 63\n-1.333 1.333-3.167 3.5-5.5 6.5s-4 4.833-5 5.5c-1 .667-2.5 1.333-4.5 2s-4.333 1\n-7 1c-4.667 0-9.167-1.833-13.5-5.5S337 184 337 178c0-12.667 15.667-32.333 47-59\nH213l-171-1c-8.667-6-13-12.333-13-19 0-4.667 4.333-11.333 13-20h359\nc-16-25.333-24-45-24-59z",widehat1:"M529 0h5l519 115c5 1 9 5 9 10 0 1-1 2-1 3l-4 22\nc-1 5-5 9-11 9h-2L532 67 19 159h-2c-5 0-9-4-11-9l-5-22c-1-6 2-12 8-13z",widehat2:"M1181 0h2l1171 176c6 0 10 5 10 11l-2 23c-1 6-5 10\n-11 10h-1L1182 67 15 220h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z",widehat3:"M1181 0h2l1171 236c6 0 10 5 10 11l-2 23c-1 6-5 10\n-11 10h-1L1182 67 15 280h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z",widehat4:"M1181 0h2l1171 296c6 0 10 5 10 11l-2 23c-1 6-5 10\n-11 10h-1L1182 67 15 340h-1c-6 0-10-4-11-10l-2-23c-1-6 4-11 10-11z",widecheck1:"M529,159h5l519,-115c5,-1,9,-5,9,-10c0,-1,-1,-2,-1,-3l-4,-22c-1,\n-5,-5,-9,-11,-9h-2l-512,92l-513,-92h-2c-5,0,-9,4,-11,9l-5,22c-1,6,2,12,8,13z",widecheck2:"M1181,220h2l1171,-176c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\n-11,-10h-1l-1168,153l-1167,-153h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z",widecheck3:"M1181,280h2l1171,-236c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\n-11,-10h-1l-1168,213l-1167,-213h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z",widecheck4:"M1181,340h2l1171,-296c6,0,10,-5,10,-11l-2,-23c-1,-6,-5,-10,\n-11,-10h-1l-1168,273l-1167,-273h-1c-6,0,-10,4,-11,10l-2,23c-1,6,4,11,10,11z",baraboveleftarrow:"M400000 620h-399890l3 -3c68.7 -52.7 113.7 -120 135 -202\nc4 -14.7 6 -23 6 -25c0 -7.3 -7 -11 -21 -11c-8 0 -13.2 0.8 -15.5 2.5\nc-2.3 1.7 -4.2 5.8 -5.5 12.5c-1.3 4.7 -2.7 10.3 -4 17c-12 48.7 -34.8 92 -68.5 130\ns-74.2 66.3 -121.5 85c-10 4 -16 7.7 -18 11c0 8.7 6 14.3 18 17c47.3 18.7 87.8 47\n121.5 85s56.5 81.3 68.5 130c0.7 2 1.3 5 2 9s1.2 6.7 1.5 8c0.3 1.3 1 3.3 2 6\ns2.2 4.5 3.5 5.5c1.3 1 3.3 1.8 6 2.5s6 1 10 1c14 0 21 -3.7 21 -11\nc0 -2 -2 -10.3 -6 -25c-20 -79.3 -65 -146.7 -135 -202l-3 -3h399890z\nM100 620v40h399900v-40z M0 241v40h399900v-40zM0 241v40h399900v-40z",rightarrowabovebar:"M0 241v40h399891c-47.3 35.3-84 78-110 128-16.7 32\n-27.7 63.7-33 95 0 1.3-.2 2.7-.5 4-.3 1.3-.5 2.3-.5 3 0 7.3 6.7 11 20 11 8 0\n13.2-.8 15.5-2.5 2.3-1.7 4.2-5.5 5.5-11.5 2-13.3 5.7-27 11-41 14.7-44.7 39\n-84.5 73-119.5s73.7-60.2 119-75.5c6-2 9-5.7 9-11s-3-9-9-11c-45.3-15.3-85-40.5\n-119-75.5s-58.3-74.8-73-119.5c-4.7-14-8.3-27.3-11-40-1.3-6.7-3.2-10.8-5.5\n-12.5-2.3-1.7-7.5-2.5-15.5-2.5-14 0-21 3.7-21 11 0 2 2 10.3 6 25 20.7 83.3 67\n151.7 139 205zm96 379h399894v40H0zm0 0h399904v40H0z",baraboveshortleftharpoon:"M507,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11\nc1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17\nc2,0.7,5,1,9,1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21\nc-32,-87.3,-82.7,-157.7,-152,-211c0,0,-3,-3,-3,-3l399351,0l0,-40\nc-398570,0,-399437,0,-399437,0z M593 435 v40 H399500 v-40z\nM0 281 v-40 H399908 v40z M0 281 v-40 H399908 v40z",rightharpoonaboveshortbar:"M0,241 l0,40c399126,0,399993,0,399993,0\nc4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199,\n-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6\nc-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z\nM0 241 v40 H399908 v-40z M0 475 v-40 H399500 v40z M0 475 v-40 H399500 v40z",shortbaraboveleftharpoon:"M7,435c-4,4,-6.3,8.7,-7,14c0,5.3,0.7,9,2,11\nc1.3,2,5.3,5.3,12,10c90.7,54,156,130,196,228c3.3,10.7,6.3,16.3,9,17c2,0.7,5,1,9,\n1c0,0,5,0,5,0c10.7,0,16.7,-2,18,-6c2,-2.7,1,-9.7,-3,-21c-32,-87.3,-82.7,-157.7,\n-152,-211c0,0,-3,-3,-3,-3l399907,0l0,-40c-399126,0,-399993,0,-399993,0z\nM93 435 v40 H400000 v-40z M500 241 v40 H400000 v-40z M500 241 v40 H400000 v-40z",shortrightharpoonabovebar:"M53,241l0,40c398570,0,399437,0,399437,0\nc4.7,-4.7,7,-9.3,7,-14c0,-9.3,-3.7,-15.3,-11,-18c-92.7,-56.7,-159,-133.7,-199,\n-231c-3.3,-9.3,-6,-14.7,-8,-16c-2,-1.3,-7,-2,-15,-2c-10.7,0,-16.7,2,-18,6\nc-2,2.7,-1,9.7,3,21c15.3,42,36.7,81.8,64,119.5c27.3,37.7,58,69.2,92,94.5z\nM500 241 v40 H399408 v-40z M500 435 v40 H400000 v-40z"};class A{constructor(e){this.children=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,this.children=e,this.classes=[],this.height=0,this.depth=0,this.maxFontSize=0,this.style={}}hasClass(e){return l.contains(this.classes,e)}toNode(){const e=document.createDocumentFragment();for(let t=0;t<this.children.length;t++)e.appendChild(this.children[t].toNode());return e}toMarkup(){let e="";for(let t=0;t<this.children.length;t++)e+=this.children[t].toMarkup();return e}toText(){return this.children.map((e=>e.toText())).join("")}}var T={"AMS-Regular":{32:[0,0,0,0,.25],65:[0,.68889,0,0,.72222],66:[0,.68889,0,0,.66667],67:[0,.68889,0,0,.72222],68:[0,.68889,0,0,.72222],69:[0,.68889,0,0,.66667],70:[0,.68889,0,0,.61111],71:[0,.68889,0,0,.77778],72:[0,.68889,0,0,.77778],73:[0,.68889,0,0,.38889],74:[.16667,.68889,0,0,.5],75:[0,.68889,0,0,.77778],76:[0,.68889,0,0,.66667],77:[0,.68889,0,0,.94445],78:[0,.68889,0,0,.72222],79:[.16667,.68889,0,0,.77778],80:[0,.68889,0,0,.61111],81:[.16667,.68889,0,0,.77778],82:[0,.68889,0,0,.72222],83:[0,.68889,0,0,.55556],84:[0,.68889,0,0,.66667],85:[0,.68889,0,0,.72222],86:[0,.68889,0,0,.72222],87:[0,.68889,0,0,1],88:[0,.68889,0,0,.72222],89:[0,.68889,0,0,.72222],90:[0,.68889,0,0,.66667],107:[0,.68889,0,0,.55556],160:[0,0,0,0,.25],165:[0,.675,.025,0,.75],174:[.15559,.69224,0,0,.94666],240:[0,.68889,0,0,.55556],295:[0,.68889,0,0,.54028],710:[0,.825,0,0,2.33334],732:[0,.9,0,0,2.33334],770:[0,.825,0,0,2.33334],771:[0,.9,0,0,2.33334],989:[.08167,.58167,0,0,.77778],1008:[0,.43056,.04028,0,.66667],8245:[0,.54986,0,0,.275],8463:[0,.68889,0,0,.54028],8487:[0,.68889,0,0,.72222],8498:[0,.68889,0,0,.55556],8502:[0,.68889,0,0,.66667],8503:[0,.68889,0,0,.44445],8504:[0,.68889,0,0,.66667],8513:[0,.68889,0,0,.63889],8592:[-.03598,.46402,0,0,.5],8594:[-.03598,.46402,0,0,.5],8602:[-.13313,.36687,0,0,1],8603:[-.13313,.36687,0,0,1],8606:[.01354,.52239,0,0,1],8608:[.01354,.52239,0,0,1],8610:[.01354,.52239,0,0,1.11111],8611:[.01354,.52239,0,0,1.11111],8619:[0,.54986,0,0,1],8620:[0,.54986,0,0,1],8621:[-.13313,.37788,0,0,1.38889],8622:[-.13313,.36687,0,0,1],8624:[0,.69224,0,0,.5],8625:[0,.69224,0,0,.5],8630:[0,.43056,0,0,1],8631:[0,.43056,0,0,1],8634:[.08198,.58198,0,0,.77778],8635:[.08198,.58198,0,0,.77778],8638:[.19444,.69224,0,0,.41667],8639:[.19444,.69224,0,0,.41667],8642:[.19444,.69224,0,0,.41667],8643:[.19444,.69224,0,0,.41667],8644:[.1808,.675,0,0,1],8646:[.1808,.675,0,0,1],8647:[.1808,.675,0,0,1],8648:[.19444,.69224,0,0,.83334],8649:[.1808,.675,0,0,1],8650:[.19444,.69224,0,0,.83334],8651:[.01354,.52239,0,0,1],8652:[.01354,.52239,0,0,1],8653:[-.13313,.36687,0,0,1],8654:[-.13313,.36687,0,0,1],8655:[-.13313,.36687,0,0,1],8666:[.13667,.63667,0,0,1],8667:[.13667,.63667,0,0,1],8669:[-.13313,.37788,0,0,1],8672:[-.064,.437,0,0,1.334],8674:[-.064,.437,0,0,1.334],8705:[0,.825,0,0,.5],8708:[0,.68889,0,0,.55556],8709:[.08167,.58167,0,0,.77778],8717:[0,.43056,0,0,.42917],8722:[-.03598,.46402,0,0,.5],8724:[.08198,.69224,0,0,.77778],8726:[.08167,.58167,0,0,.77778],8733:[0,.69224,0,0,.77778],8736:[0,.69224,0,0,.72222],8737:[0,.69224,0,0,.72222],8738:[.03517,.52239,0,0,.72222],8739:[.08167,.58167,0,0,.22222],8740:[.25142,.74111,0,0,.27778],8741:[.08167,.58167,0,0,.38889],8742:[.25142,.74111,0,0,.5],8756:[0,.69224,0,0,.66667],8757:[0,.69224,0,0,.66667],8764:[-.13313,.36687,0,0,.77778],8765:[-.13313,.37788,0,0,.77778],8769:[-.13313,.36687,0,0,.77778],8770:[-.03625,.46375,0,0,.77778],8774:[.30274,.79383,0,0,.77778],8776:[-.01688,.48312,0,0,.77778],8778:[.08167,.58167,0,0,.77778],8782:[.06062,.54986,0,0,.77778],8783:[.06062,.54986,0,0,.77778],8785:[.08198,.58198,0,0,.77778],8786:[.08198,.58198,0,0,.77778],8787:[.08198,.58198,0,0,.77778],8790:[0,.69224,0,0,.77778],8791:[.22958,.72958,0,0,.77778],8796:[.08198,.91667,0,0,.77778],8806:[.25583,.75583,0,0,.77778],8807:[.25583,.75583,0,0,.77778],8808:[.25142,.75726,0,0,.77778],8809:[.25142,.75726,0,0,.77778],8812:[.25583,.75583,0,0,.5],8814:[.20576,.70576,0,0,.77778],8815:[.20576,.70576,0,0,.77778],8816:[.30274,.79383,0,0,.77778],8817:[.30274,.79383,0,0,.77778],8818:[.22958,.72958,0,0,.77778],8819:[.22958,.72958,0,0,.77778],8822:[.1808,.675,0,0,.77778],8823:[.1808,.675,0,0,.77778],8828:[.13667,.63667,0,0,.77778],8829:[.13667,.63667,0,0,.77778],8830:[.22958,.72958,0,0,.77778],8831:[.22958,.72958,0,0,.77778],8832:[.20576,.70576,0,0,.77778],8833:[.20576,.70576,0,0,.77778],8840:[.30274,.79383,0,0,.77778],8841:[.30274,.79383,0,0,.77778],8842:[.13597,.63597,0,0,.77778],8843:[.13597,.63597,0,0,.77778],8847:[.03517,.54986,0,0,.77778],8848:[.03517,.54986,0,0,.77778],8858:[.08198,.58198,0,0,.77778],8859:[.08198,.58198,0,0,.77778],8861:[.08198,.58198,0,0,.77778],8862:[0,.675,0,0,.77778],8863:[0,.675,0,0,.77778],8864:[0,.675,0,0,.77778],8865:[0,.675,0,0,.77778],8872:[0,.69224,0,0,.61111],8873:[0,.69224,0,0,.72222],8874:[0,.69224,0,0,.88889],8876:[0,.68889,0,0,.61111],8877:[0,.68889,0,0,.61111],8878:[0,.68889,0,0,.72222],8879:[0,.68889,0,0,.72222],8882:[.03517,.54986,0,0,.77778],8883:[.03517,.54986,0,0,.77778],8884:[.13667,.63667,0,0,.77778],8885:[.13667,.63667,0,0,.77778],8888:[0,.54986,0,0,1.11111],8890:[.19444,.43056,0,0,.55556],8891:[.19444,.69224,0,0,.61111],8892:[.19444,.69224,0,0,.61111],8901:[0,.54986,0,0,.27778],8903:[.08167,.58167,0,0,.77778],8905:[.08167,.58167,0,0,.77778],8906:[.08167,.58167,0,0,.77778],8907:[0,.69224,0,0,.77778],8908:[0,.69224,0,0,.77778],8909:[-.03598,.46402,0,0,.77778],8910:[0,.54986,0,0,.76042],8911:[0,.54986,0,0,.76042],8912:[.03517,.54986,0,0,.77778],8913:[.03517,.54986,0,0,.77778],8914:[0,.54986,0,0,.66667],8915:[0,.54986,0,0,.66667],8916:[0,.69224,0,0,.66667],8918:[.0391,.5391,0,0,.77778],8919:[.0391,.5391,0,0,.77778],8920:[.03517,.54986,0,0,1.33334],8921:[.03517,.54986,0,0,1.33334],8922:[.38569,.88569,0,0,.77778],8923:[.38569,.88569,0,0,.77778],8926:[.13667,.63667,0,0,.77778],8927:[.13667,.63667,0,0,.77778],8928:[.30274,.79383,0,0,.77778],8929:[.30274,.79383,0,0,.77778],8934:[.23222,.74111,0,0,.77778],8935:[.23222,.74111,0,0,.77778],8936:[.23222,.74111,0,0,.77778],8937:[.23222,.74111,0,0,.77778],8938:[.20576,.70576,0,0,.77778],8939:[.20576,.70576,0,0,.77778],8940:[.30274,.79383,0,0,.77778],8941:[.30274,.79383,0,0,.77778],8994:[.19444,.69224,0,0,.77778],8995:[.19444,.69224,0,0,.77778],9416:[.15559,.69224,0,0,.90222],9484:[0,.69224,0,0,.5],9488:[0,.69224,0,0,.5],9492:[0,.37788,0,0,.5],9496:[0,.37788,0,0,.5],9585:[.19444,.68889,0,0,.88889],9586:[.19444,.74111,0,0,.88889],9632:[0,.675,0,0,.77778],9633:[0,.675,0,0,.77778],9650:[0,.54986,0,0,.72222],9651:[0,.54986,0,0,.72222],9654:[.03517,.54986,0,0,.77778],9660:[0,.54986,0,0,.72222],9661:[0,.54986,0,0,.72222],9664:[.03517,.54986,0,0,.77778],9674:[.11111,.69224,0,0,.66667],9733:[.19444,.69224,0,0,.94445],10003:[0,.69224,0,0,.83334],10016:[0,.69224,0,0,.83334],10731:[.11111,.69224,0,0,.66667],10846:[.19444,.75583,0,0,.61111],10877:[.13667,.63667,0,0,.77778],10878:[.13667,.63667,0,0,.77778],10885:[.25583,.75583,0,0,.77778],10886:[.25583,.75583,0,0,.77778],10887:[.13597,.63597,0,0,.77778],10888:[.13597,.63597,0,0,.77778],10889:[.26167,.75726,0,0,.77778],10890:[.26167,.75726,0,0,.77778],10891:[.48256,.98256,0,0,.77778],10892:[.48256,.98256,0,0,.77778],10901:[.13667,.63667,0,0,.77778],10902:[.13667,.63667,0,0,.77778],10933:[.25142,.75726,0,0,.77778],10934:[.25142,.75726,0,0,.77778],10935:[.26167,.75726,0,0,.77778],10936:[.26167,.75726,0,0,.77778],10937:[.26167,.75726,0,0,.77778],10938:[.26167,.75726,0,0,.77778],10949:[.25583,.75583,0,0,.77778],10950:[.25583,.75583,0,0,.77778],10955:[.28481,.79383,0,0,.77778],10956:[.28481,.79383,0,0,.77778],57350:[.08167,.58167,0,0,.22222],57351:[.08167,.58167,0,0,.38889],57352:[.08167,.58167,0,0,.77778],57353:[0,.43056,.04028,0,.66667],57356:[.25142,.75726,0,0,.77778],57357:[.25142,.75726,0,0,.77778],57358:[.41951,.91951,0,0,.77778],57359:[.30274,.79383,0,0,.77778],57360:[.30274,.79383,0,0,.77778],57361:[.41951,.91951,0,0,.77778],57366:[.25142,.75726,0,0,.77778],57367:[.25142,.75726,0,0,.77778],57368:[.25142,.75726,0,0,.77778],57369:[.25142,.75726,0,0,.77778],57370:[.13597,.63597,0,0,.77778],57371:[.13597,.63597,0,0,.77778]},"Caligraphic-Regular":{32:[0,0,0,0,.25],65:[0,.68333,0,.19445,.79847],66:[0,.68333,.03041,.13889,.65681],67:[0,.68333,.05834,.13889,.52653],68:[0,.68333,.02778,.08334,.77139],69:[0,.68333,.08944,.11111,.52778],70:[0,.68333,.09931,.11111,.71875],71:[.09722,.68333,.0593,.11111,.59487],72:[0,.68333,.00965,.11111,.84452],73:[0,.68333,.07382,0,.54452],74:[.09722,.68333,.18472,.16667,.67778],75:[0,.68333,.01445,.05556,.76195],76:[0,.68333,0,.13889,.68972],77:[0,.68333,0,.13889,1.2009],78:[0,.68333,.14736,.08334,.82049],79:[0,.68333,.02778,.11111,.79611],80:[0,.68333,.08222,.08334,.69556],81:[.09722,.68333,0,.11111,.81667],82:[0,.68333,0,.08334,.8475],83:[0,.68333,.075,.13889,.60556],84:[0,.68333,.25417,0,.54464],85:[0,.68333,.09931,.08334,.62583],86:[0,.68333,.08222,0,.61278],87:[0,.68333,.08222,.08334,.98778],88:[0,.68333,.14643,.13889,.7133],89:[.09722,.68333,.08222,.08334,.66834],90:[0,.68333,.07944,.13889,.72473],160:[0,0,0,0,.25]},"Fraktur-Regular":{32:[0,0,0,0,.25],33:[0,.69141,0,0,.29574],34:[0,.69141,0,0,.21471],38:[0,.69141,0,0,.73786],39:[0,.69141,0,0,.21201],40:[.24982,.74947,0,0,.38865],41:[.24982,.74947,0,0,.38865],42:[0,.62119,0,0,.27764],43:[.08319,.58283,0,0,.75623],44:[0,.10803,0,0,.27764],45:[.08319,.58283,0,0,.75623],46:[0,.10803,0,0,.27764],47:[.24982,.74947,0,0,.50181],48:[0,.47534,0,0,.50181],49:[0,.47534,0,0,.50181],50:[0,.47534,0,0,.50181],51:[.18906,.47534,0,0,.50181],52:[.18906,.47534,0,0,.50181],53:[.18906,.47534,0,0,.50181],54:[0,.69141,0,0,.50181],55:[.18906,.47534,0,0,.50181],56:[0,.69141,0,0,.50181],57:[.18906,.47534,0,0,.50181],58:[0,.47534,0,0,.21606],59:[.12604,.47534,0,0,.21606],61:[-.13099,.36866,0,0,.75623],63:[0,.69141,0,0,.36245],65:[0,.69141,0,0,.7176],66:[0,.69141,0,0,.88397],67:[0,.69141,0,0,.61254],68:[0,.69141,0,0,.83158],69:[0,.69141,0,0,.66278],70:[.12604,.69141,0,0,.61119],71:[0,.69141,0,0,.78539],72:[.06302,.69141,0,0,.7203],73:[0,.69141,0,0,.55448],74:[.12604,.69141,0,0,.55231],75:[0,.69141,0,0,.66845],76:[0,.69141,0,0,.66602],77:[0,.69141,0,0,1.04953],78:[0,.69141,0,0,.83212],79:[0,.69141,0,0,.82699],80:[.18906,.69141,0,0,.82753],81:[.03781,.69141,0,0,.82699],82:[0,.69141,0,0,.82807],83:[0,.69141,0,0,.82861],84:[0,.69141,0,0,.66899],85:[0,.69141,0,0,.64576],86:[0,.69141,0,0,.83131],87:[0,.69141,0,0,1.04602],88:[0,.69141,0,0,.71922],89:[.18906,.69141,0,0,.83293],90:[.12604,.69141,0,0,.60201],91:[.24982,.74947,0,0,.27764],93:[.24982,.74947,0,0,.27764],94:[0,.69141,0,0,.49965],97:[0,.47534,0,0,.50046],98:[0,.69141,0,0,.51315],99:[0,.47534,0,0,.38946],100:[0,.62119,0,0,.49857],101:[0,.47534,0,0,.40053],102:[.18906,.69141,0,0,.32626],103:[.18906,.47534,0,0,.5037],104:[.18906,.69141,0,0,.52126],105:[0,.69141,0,0,.27899],106:[0,.69141,0,0,.28088],107:[0,.69141,0,0,.38946],108:[0,.69141,0,0,.27953],109:[0,.47534,0,0,.76676],110:[0,.47534,0,0,.52666],111:[0,.47534,0,0,.48885],112:[.18906,.52396,0,0,.50046],113:[.18906,.47534,0,0,.48912],114:[0,.47534,0,0,.38919],115:[0,.47534,0,0,.44266],116:[0,.62119,0,0,.33301],117:[0,.47534,0,0,.5172],118:[0,.52396,0,0,.5118],119:[0,.52396,0,0,.77351],120:[.18906,.47534,0,0,.38865],121:[.18906,.47534,0,0,.49884],122:[.18906,.47534,0,0,.39054],160:[0,0,0,0,.25],8216:[0,.69141,0,0,.21471],8217:[0,.69141,0,0,.21471],58112:[0,.62119,0,0,.49749],58113:[0,.62119,0,0,.4983],58114:[.18906,.69141,0,0,.33328],58115:[.18906,.69141,0,0,.32923],58116:[.18906,.47534,0,0,.50343],58117:[0,.69141,0,0,.33301],58118:[0,.62119,0,0,.33409],58119:[0,.47534,0,0,.50073]},"Main-Bold":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.35],34:[0,.69444,0,0,.60278],35:[.19444,.69444,0,0,.95833],36:[.05556,.75,0,0,.575],37:[.05556,.75,0,0,.95833],38:[0,.69444,0,0,.89444],39:[0,.69444,0,0,.31944],40:[.25,.75,0,0,.44722],41:[.25,.75,0,0,.44722],42:[0,.75,0,0,.575],43:[.13333,.63333,0,0,.89444],44:[.19444,.15556,0,0,.31944],45:[0,.44444,0,0,.38333],46:[0,.15556,0,0,.31944],47:[.25,.75,0,0,.575],48:[0,.64444,0,0,.575],49:[0,.64444,0,0,.575],50:[0,.64444,0,0,.575],51:[0,.64444,0,0,.575],52:[0,.64444,0,0,.575],53:[0,.64444,0,0,.575],54:[0,.64444,0,0,.575],55:[0,.64444,0,0,.575],56:[0,.64444,0,0,.575],57:[0,.64444,0,0,.575],58:[0,.44444,0,0,.31944],59:[.19444,.44444,0,0,.31944],60:[.08556,.58556,0,0,.89444],61:[-.10889,.39111,0,0,.89444],62:[.08556,.58556,0,0,.89444],63:[0,.69444,0,0,.54305],64:[0,.69444,0,0,.89444],65:[0,.68611,0,0,.86944],66:[0,.68611,0,0,.81805],67:[0,.68611,0,0,.83055],68:[0,.68611,0,0,.88194],69:[0,.68611,0,0,.75555],70:[0,.68611,0,0,.72361],71:[0,.68611,0,0,.90416],72:[0,.68611,0,0,.9],73:[0,.68611,0,0,.43611],74:[0,.68611,0,0,.59444],75:[0,.68611,0,0,.90138],76:[0,.68611,0,0,.69166],77:[0,.68611,0,0,1.09166],78:[0,.68611,0,0,.9],79:[0,.68611,0,0,.86388],80:[0,.68611,0,0,.78611],81:[.19444,.68611,0,0,.86388],82:[0,.68611,0,0,.8625],83:[0,.68611,0,0,.63889],84:[0,.68611,0,0,.8],85:[0,.68611,0,0,.88472],86:[0,.68611,.01597,0,.86944],87:[0,.68611,.01597,0,1.18888],88:[0,.68611,0,0,.86944],89:[0,.68611,.02875,0,.86944],90:[0,.68611,0,0,.70277],91:[.25,.75,0,0,.31944],92:[.25,.75,0,0,.575],93:[.25,.75,0,0,.31944],94:[0,.69444,0,0,.575],95:[.31,.13444,.03194,0,.575],97:[0,.44444,0,0,.55902],98:[0,.69444,0,0,.63889],99:[0,.44444,0,0,.51111],100:[0,.69444,0,0,.63889],101:[0,.44444,0,0,.52708],102:[0,.69444,.10903,0,.35139],103:[.19444,.44444,.01597,0,.575],104:[0,.69444,0,0,.63889],105:[0,.69444,0,0,.31944],106:[.19444,.69444,0,0,.35139],107:[0,.69444,0,0,.60694],108:[0,.69444,0,0,.31944],109:[0,.44444,0,0,.95833],110:[0,.44444,0,0,.63889],111:[0,.44444,0,0,.575],112:[.19444,.44444,0,0,.63889],113:[.19444,.44444,0,0,.60694],114:[0,.44444,0,0,.47361],115:[0,.44444,0,0,.45361],116:[0,.63492,0,0,.44722],117:[0,.44444,0,0,.63889],118:[0,.44444,.01597,0,.60694],119:[0,.44444,.01597,0,.83055],120:[0,.44444,0,0,.60694],121:[.19444,.44444,.01597,0,.60694],122:[0,.44444,0,0,.51111],123:[.25,.75,0,0,.575],124:[.25,.75,0,0,.31944],125:[.25,.75,0,0,.575],126:[.35,.34444,0,0,.575],160:[0,0,0,0,.25],163:[0,.69444,0,0,.86853],168:[0,.69444,0,0,.575],172:[0,.44444,0,0,.76666],176:[0,.69444,0,0,.86944],177:[.13333,.63333,0,0,.89444],184:[.17014,0,0,0,.51111],198:[0,.68611,0,0,1.04166],215:[.13333,.63333,0,0,.89444],216:[.04861,.73472,0,0,.89444],223:[0,.69444,0,0,.59722],230:[0,.44444,0,0,.83055],247:[.13333,.63333,0,0,.89444],248:[.09722,.54167,0,0,.575],305:[0,.44444,0,0,.31944],338:[0,.68611,0,0,1.16944],339:[0,.44444,0,0,.89444],567:[.19444,.44444,0,0,.35139],710:[0,.69444,0,0,.575],711:[0,.63194,0,0,.575],713:[0,.59611,0,0,.575],714:[0,.69444,0,0,.575],715:[0,.69444,0,0,.575],728:[0,.69444,0,0,.575],729:[0,.69444,0,0,.31944],730:[0,.69444,0,0,.86944],732:[0,.69444,0,0,.575],733:[0,.69444,0,0,.575],915:[0,.68611,0,0,.69166],916:[0,.68611,0,0,.95833],920:[0,.68611,0,0,.89444],923:[0,.68611,0,0,.80555],926:[0,.68611,0,0,.76666],928:[0,.68611,0,0,.9],931:[0,.68611,0,0,.83055],933:[0,.68611,0,0,.89444],934:[0,.68611,0,0,.83055],936:[0,.68611,0,0,.89444],937:[0,.68611,0,0,.83055],8211:[0,.44444,.03194,0,.575],8212:[0,.44444,.03194,0,1.14999],8216:[0,.69444,0,0,.31944],8217:[0,.69444,0,0,.31944],8220:[0,.69444,0,0,.60278],8221:[0,.69444,0,0,.60278],8224:[.19444,.69444,0,0,.51111],8225:[.19444,.69444,0,0,.51111],8242:[0,.55556,0,0,.34444],8407:[0,.72444,.15486,0,.575],8463:[0,.69444,0,0,.66759],8465:[0,.69444,0,0,.83055],8467:[0,.69444,0,0,.47361],8472:[.19444,.44444,0,0,.74027],8476:[0,.69444,0,0,.83055],8501:[0,.69444,0,0,.70277],8592:[-.10889,.39111,0,0,1.14999],8593:[.19444,.69444,0,0,.575],8594:[-.10889,.39111,0,0,1.14999],8595:[.19444,.69444,0,0,.575],8596:[-.10889,.39111,0,0,1.14999],8597:[.25,.75,0,0,.575],8598:[.19444,.69444,0,0,1.14999],8599:[.19444,.69444,0,0,1.14999],8600:[.19444,.69444,0,0,1.14999],8601:[.19444,.69444,0,0,1.14999],8636:[-.10889,.39111,0,0,1.14999],8637:[-.10889,.39111,0,0,1.14999],8640:[-.10889,.39111,0,0,1.14999],8641:[-.10889,.39111,0,0,1.14999],8656:[-.10889,.39111,0,0,1.14999],8657:[.19444,.69444,0,0,.70277],8658:[-.10889,.39111,0,0,1.14999],8659:[.19444,.69444,0,0,.70277],8660:[-.10889,.39111,0,0,1.14999],8661:[.25,.75,0,0,.70277],8704:[0,.69444,0,0,.63889],8706:[0,.69444,.06389,0,.62847],8707:[0,.69444,0,0,.63889],8709:[.05556,.75,0,0,.575],8711:[0,.68611,0,0,.95833],8712:[.08556,.58556,0,0,.76666],8715:[.08556,.58556,0,0,.76666],8722:[.13333,.63333,0,0,.89444],8723:[.13333,.63333,0,0,.89444],8725:[.25,.75,0,0,.575],8726:[.25,.75,0,0,.575],8727:[-.02778,.47222,0,0,.575],8728:[-.02639,.47361,0,0,.575],8729:[-.02639,.47361,0,0,.575],8730:[.18,.82,0,0,.95833],8733:[0,.44444,0,0,.89444],8734:[0,.44444,0,0,1.14999],8736:[0,.69224,0,0,.72222],8739:[.25,.75,0,0,.31944],8741:[.25,.75,0,0,.575],8743:[0,.55556,0,0,.76666],8744:[0,.55556,0,0,.76666],8745:[0,.55556,0,0,.76666],8746:[0,.55556,0,0,.76666],8747:[.19444,.69444,.12778,0,.56875],8764:[-.10889,.39111,0,0,.89444],8768:[.19444,.69444,0,0,.31944],8771:[.00222,.50222,0,0,.89444],8773:[.027,.638,0,0,.894],8776:[.02444,.52444,0,0,.89444],8781:[.00222,.50222,0,0,.89444],8801:[.00222,.50222,0,0,.89444],8804:[.19667,.69667,0,0,.89444],8805:[.19667,.69667,0,0,.89444],8810:[.08556,.58556,0,0,1.14999],8811:[.08556,.58556,0,0,1.14999],8826:[.08556,.58556,0,0,.89444],8827:[.08556,.58556,0,0,.89444],8834:[.08556,.58556,0,0,.89444],8835:[.08556,.58556,0,0,.89444],8838:[.19667,.69667,0,0,.89444],8839:[.19667,.69667,0,0,.89444],8846:[0,.55556,0,0,.76666],8849:[.19667,.69667,0,0,.89444],8850:[.19667,.69667,0,0,.89444],8851:[0,.55556,0,0,.76666],8852:[0,.55556,0,0,.76666],8853:[.13333,.63333,0,0,.89444],8854:[.13333,.63333,0,0,.89444],8855:[.13333,.63333,0,0,.89444],8856:[.13333,.63333,0,0,.89444],8857:[.13333,.63333,0,0,.89444],8866:[0,.69444,0,0,.70277],8867:[0,.69444,0,0,.70277],8868:[0,.69444,0,0,.89444],8869:[0,.69444,0,0,.89444],8900:[-.02639,.47361,0,0,.575],8901:[-.02639,.47361,0,0,.31944],8902:[-.02778,.47222,0,0,.575],8968:[.25,.75,0,0,.51111],8969:[.25,.75,0,0,.51111],8970:[.25,.75,0,0,.51111],8971:[.25,.75,0,0,.51111],8994:[-.13889,.36111,0,0,1.14999],8995:[-.13889,.36111,0,0,1.14999],9651:[.19444,.69444,0,0,1.02222],9657:[-.02778,.47222,0,0,.575],9661:[.19444,.69444,0,0,1.02222],9667:[-.02778,.47222,0,0,.575],9711:[.19444,.69444,0,0,1.14999],9824:[.12963,.69444,0,0,.89444],9825:[.12963,.69444,0,0,.89444],9826:[.12963,.69444,0,0,.89444],9827:[.12963,.69444,0,0,.89444],9837:[0,.75,0,0,.44722],9838:[.19444,.69444,0,0,.44722],9839:[.19444,.69444,0,0,.44722],10216:[.25,.75,0,0,.44722],10217:[.25,.75,0,0,.44722],10815:[0,.68611,0,0,.9],10927:[.19667,.69667,0,0,.89444],10928:[.19667,.69667,0,0,.89444],57376:[.19444,.69444,0,0,0]},"Main-BoldItalic":{32:[0,0,0,0,.25],33:[0,.69444,.11417,0,.38611],34:[0,.69444,.07939,0,.62055],35:[.19444,.69444,.06833,0,.94444],37:[.05556,.75,.12861,0,.94444],38:[0,.69444,.08528,0,.88555],39:[0,.69444,.12945,0,.35555],40:[.25,.75,.15806,0,.47333],41:[.25,.75,.03306,0,.47333],42:[0,.75,.14333,0,.59111],43:[.10333,.60333,.03306,0,.88555],44:[.19444,.14722,0,0,.35555],45:[0,.44444,.02611,0,.41444],46:[0,.14722,0,0,.35555],47:[.25,.75,.15806,0,.59111],48:[0,.64444,.13167,0,.59111],49:[0,.64444,.13167,0,.59111],50:[0,.64444,.13167,0,.59111],51:[0,.64444,.13167,0,.59111],52:[.19444,.64444,.13167,0,.59111],53:[0,.64444,.13167,0,.59111],54:[0,.64444,.13167,0,.59111],55:[.19444,.64444,.13167,0,.59111],56:[0,.64444,.13167,0,.59111],57:[0,.64444,.13167,0,.59111],58:[0,.44444,.06695,0,.35555],59:[.19444,.44444,.06695,0,.35555],61:[-.10889,.39111,.06833,0,.88555],63:[0,.69444,.11472,0,.59111],64:[0,.69444,.09208,0,.88555],65:[0,.68611,0,0,.86555],66:[0,.68611,.0992,0,.81666],67:[0,.68611,.14208,0,.82666],68:[0,.68611,.09062,0,.87555],69:[0,.68611,.11431,0,.75666],70:[0,.68611,.12903,0,.72722],71:[0,.68611,.07347,0,.89527],72:[0,.68611,.17208,0,.8961],73:[0,.68611,.15681,0,.47166],74:[0,.68611,.145,0,.61055],75:[0,.68611,.14208,0,.89499],76:[0,.68611,0,0,.69777],77:[0,.68611,.17208,0,1.07277],78:[0,.68611,.17208,0,.8961],79:[0,.68611,.09062,0,.85499],80:[0,.68611,.0992,0,.78721],81:[.19444,.68611,.09062,0,.85499],82:[0,.68611,.02559,0,.85944],83:[0,.68611,.11264,0,.64999],84:[0,.68611,.12903,0,.7961],85:[0,.68611,.17208,0,.88083],86:[0,.68611,.18625,0,.86555],87:[0,.68611,.18625,0,1.15999],88:[0,.68611,.15681,0,.86555],89:[0,.68611,.19803,0,.86555],90:[0,.68611,.14208,0,.70888],91:[.25,.75,.1875,0,.35611],93:[.25,.75,.09972,0,.35611],94:[0,.69444,.06709,0,.59111],95:[.31,.13444,.09811,0,.59111],97:[0,.44444,.09426,0,.59111],98:[0,.69444,.07861,0,.53222],99:[0,.44444,.05222,0,.53222],100:[0,.69444,.10861,0,.59111],101:[0,.44444,.085,0,.53222],102:[.19444,.69444,.21778,0,.4],103:[.19444,.44444,.105,0,.53222],104:[0,.69444,.09426,0,.59111],105:[0,.69326,.11387,0,.35555],106:[.19444,.69326,.1672,0,.35555],107:[0,.69444,.11111,0,.53222],108:[0,.69444,.10861,0,.29666],109:[0,.44444,.09426,0,.94444],110:[0,.44444,.09426,0,.64999],111:[0,.44444,.07861,0,.59111],112:[.19444,.44444,.07861,0,.59111],113:[.19444,.44444,.105,0,.53222],114:[0,.44444,.11111,0,.50167],115:[0,.44444,.08167,0,.48694],116:[0,.63492,.09639,0,.385],117:[0,.44444,.09426,0,.62055],118:[0,.44444,.11111,0,.53222],119:[0,.44444,.11111,0,.76777],120:[0,.44444,.12583,0,.56055],121:[.19444,.44444,.105,0,.56166],122:[0,.44444,.13889,0,.49055],126:[.35,.34444,.11472,0,.59111],160:[0,0,0,0,.25],168:[0,.69444,.11473,0,.59111],176:[0,.69444,0,0,.94888],184:[.17014,0,0,0,.53222],198:[0,.68611,.11431,0,1.02277],216:[.04861,.73472,.09062,0,.88555],223:[.19444,.69444,.09736,0,.665],230:[0,.44444,.085,0,.82666],248:[.09722,.54167,.09458,0,.59111],305:[0,.44444,.09426,0,.35555],338:[0,.68611,.11431,0,1.14054],339:[0,.44444,.085,0,.82666],567:[.19444,.44444,.04611,0,.385],710:[0,.69444,.06709,0,.59111],711:[0,.63194,.08271,0,.59111],713:[0,.59444,.10444,0,.59111],714:[0,.69444,.08528,0,.59111],715:[0,.69444,0,0,.59111],728:[0,.69444,.10333,0,.59111],729:[0,.69444,.12945,0,.35555],730:[0,.69444,0,0,.94888],732:[0,.69444,.11472,0,.59111],733:[0,.69444,.11472,0,.59111],915:[0,.68611,.12903,0,.69777],916:[0,.68611,0,0,.94444],920:[0,.68611,.09062,0,.88555],923:[0,.68611,0,0,.80666],926:[0,.68611,.15092,0,.76777],928:[0,.68611,.17208,0,.8961],931:[0,.68611,.11431,0,.82666],933:[0,.68611,.10778,0,.88555],934:[0,.68611,.05632,0,.82666],936:[0,.68611,.10778,0,.88555],937:[0,.68611,.0992,0,.82666],8211:[0,.44444,.09811,0,.59111],8212:[0,.44444,.09811,0,1.18221],8216:[0,.69444,.12945,0,.35555],8217:[0,.69444,.12945,0,.35555],8220:[0,.69444,.16772,0,.62055],8221:[0,.69444,.07939,0,.62055]},"Main-Italic":{32:[0,0,0,0,.25],33:[0,.69444,.12417,0,.30667],34:[0,.69444,.06961,0,.51444],35:[.19444,.69444,.06616,0,.81777],37:[.05556,.75,.13639,0,.81777],38:[0,.69444,.09694,0,.76666],39:[0,.69444,.12417,0,.30667],40:[.25,.75,.16194,0,.40889],41:[.25,.75,.03694,0,.40889],42:[0,.75,.14917,0,.51111],43:[.05667,.56167,.03694,0,.76666],44:[.19444,.10556,0,0,.30667],45:[0,.43056,.02826,0,.35778],46:[0,.10556,0,0,.30667],47:[.25,.75,.16194,0,.51111],48:[0,.64444,.13556,0,.51111],49:[0,.64444,.13556,0,.51111],50:[0,.64444,.13556,0,.51111],51:[0,.64444,.13556,0,.51111],52:[.19444,.64444,.13556,0,.51111],53:[0,.64444,.13556,0,.51111],54:[0,.64444,.13556,0,.51111],55:[.19444,.64444,.13556,0,.51111],56:[0,.64444,.13556,0,.51111],57:[0,.64444,.13556,0,.51111],58:[0,.43056,.0582,0,.30667],59:[.19444,.43056,.0582,0,.30667],61:[-.13313,.36687,.06616,0,.76666],63:[0,.69444,.1225,0,.51111],64:[0,.69444,.09597,0,.76666],65:[0,.68333,0,0,.74333],66:[0,.68333,.10257,0,.70389],67:[0,.68333,.14528,0,.71555],68:[0,.68333,.09403,0,.755],69:[0,.68333,.12028,0,.67833],70:[0,.68333,.13305,0,.65277],71:[0,.68333,.08722,0,.77361],72:[0,.68333,.16389,0,.74333],73:[0,.68333,.15806,0,.38555],74:[0,.68333,.14028,0,.525],75:[0,.68333,.14528,0,.76888],76:[0,.68333,0,0,.62722],77:[0,.68333,.16389,0,.89666],78:[0,.68333,.16389,0,.74333],79:[0,.68333,.09403,0,.76666],80:[0,.68333,.10257,0,.67833],81:[.19444,.68333,.09403,0,.76666],82:[0,.68333,.03868,0,.72944],83:[0,.68333,.11972,0,.56222],84:[0,.68333,.13305,0,.71555],85:[0,.68333,.16389,0,.74333],86:[0,.68333,.18361,0,.74333],87:[0,.68333,.18361,0,.99888],88:[0,.68333,.15806,0,.74333],89:[0,.68333,.19383,0,.74333],90:[0,.68333,.14528,0,.61333],91:[.25,.75,.1875,0,.30667],93:[.25,.75,.10528,0,.30667],94:[0,.69444,.06646,0,.51111],95:[.31,.12056,.09208,0,.51111],97:[0,.43056,.07671,0,.51111],98:[0,.69444,.06312,0,.46],99:[0,.43056,.05653,0,.46],100:[0,.69444,.10333,0,.51111],101:[0,.43056,.07514,0,.46],102:[.19444,.69444,.21194,0,.30667],103:[.19444,.43056,.08847,0,.46],104:[0,.69444,.07671,0,.51111],105:[0,.65536,.1019,0,.30667],106:[.19444,.65536,.14467,0,.30667],107:[0,.69444,.10764,0,.46],108:[0,.69444,.10333,0,.25555],109:[0,.43056,.07671,0,.81777],110:[0,.43056,.07671,0,.56222],111:[0,.43056,.06312,0,.51111],112:[.19444,.43056,.06312,0,.51111],113:[.19444,.43056,.08847,0,.46],114:[0,.43056,.10764,0,.42166],115:[0,.43056,.08208,0,.40889],116:[0,.61508,.09486,0,.33222],117:[0,.43056,.07671,0,.53666],118:[0,.43056,.10764,0,.46],119:[0,.43056,.10764,0,.66444],120:[0,.43056,.12042,0,.46389],121:[.19444,.43056,.08847,0,.48555],122:[0,.43056,.12292,0,.40889],126:[.35,.31786,.11585,0,.51111],160:[0,0,0,0,.25],168:[0,.66786,.10474,0,.51111],176:[0,.69444,0,0,.83129],184:[.17014,0,0,0,.46],198:[0,.68333,.12028,0,.88277],216:[.04861,.73194,.09403,0,.76666],223:[.19444,.69444,.10514,0,.53666],230:[0,.43056,.07514,0,.71555],248:[.09722,.52778,.09194,0,.51111],338:[0,.68333,.12028,0,.98499],339:[0,.43056,.07514,0,.71555],710:[0,.69444,.06646,0,.51111],711:[0,.62847,.08295,0,.51111],713:[0,.56167,.10333,0,.51111],714:[0,.69444,.09694,0,.51111],715:[0,.69444,0,0,.51111],728:[0,.69444,.10806,0,.51111],729:[0,.66786,.11752,0,.30667],730:[0,.69444,0,0,.83129],732:[0,.66786,.11585,0,.51111],733:[0,.69444,.1225,0,.51111],915:[0,.68333,.13305,0,.62722],916:[0,.68333,0,0,.81777],920:[0,.68333,.09403,0,.76666],923:[0,.68333,0,0,.69222],926:[0,.68333,.15294,0,.66444],928:[0,.68333,.16389,0,.74333],931:[0,.68333,.12028,0,.71555],933:[0,.68333,.11111,0,.76666],934:[0,.68333,.05986,0,.71555],936:[0,.68333,.11111,0,.76666],937:[0,.68333,.10257,0,.71555],8211:[0,.43056,.09208,0,.51111],8212:[0,.43056,.09208,0,1.02222],8216:[0,.69444,.12417,0,.30667],8217:[0,.69444,.12417,0,.30667],8220:[0,.69444,.1685,0,.51444],8221:[0,.69444,.06961,0,.51444],8463:[0,.68889,0,0,.54028]},"Main-Regular":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.27778],34:[0,.69444,0,0,.5],35:[.19444,.69444,0,0,.83334],36:[.05556,.75,0,0,.5],37:[.05556,.75,0,0,.83334],38:[0,.69444,0,0,.77778],39:[0,.69444,0,0,.27778],40:[.25,.75,0,0,.38889],41:[.25,.75,0,0,.38889],42:[0,.75,0,0,.5],43:[.08333,.58333,0,0,.77778],44:[.19444,.10556,0,0,.27778],45:[0,.43056,0,0,.33333],46:[0,.10556,0,0,.27778],47:[.25,.75,0,0,.5],48:[0,.64444,0,0,.5],49:[0,.64444,0,0,.5],50:[0,.64444,0,0,.5],51:[0,.64444,0,0,.5],52:[0,.64444,0,0,.5],53:[0,.64444,0,0,.5],54:[0,.64444,0,0,.5],55:[0,.64444,0,0,.5],56:[0,.64444,0,0,.5],57:[0,.64444,0,0,.5],58:[0,.43056,0,0,.27778],59:[.19444,.43056,0,0,.27778],60:[.0391,.5391,0,0,.77778],61:[-.13313,.36687,0,0,.77778],62:[.0391,.5391,0,0,.77778],63:[0,.69444,0,0,.47222],64:[0,.69444,0,0,.77778],65:[0,.68333,0,0,.75],66:[0,.68333,0,0,.70834],67:[0,.68333,0,0,.72222],68:[0,.68333,0,0,.76389],69:[0,.68333,0,0,.68056],70:[0,.68333,0,0,.65278],71:[0,.68333,0,0,.78472],72:[0,.68333,0,0,.75],73:[0,.68333,0,0,.36111],74:[0,.68333,0,0,.51389],75:[0,.68333,0,0,.77778],76:[0,.68333,0,0,.625],77:[0,.68333,0,0,.91667],78:[0,.68333,0,0,.75],79:[0,.68333,0,0,.77778],80:[0,.68333,0,0,.68056],81:[.19444,.68333,0,0,.77778],82:[0,.68333,0,0,.73611],83:[0,.68333,0,0,.55556],84:[0,.68333,0,0,.72222],85:[0,.68333,0,0,.75],86:[0,.68333,.01389,0,.75],87:[0,.68333,.01389,0,1.02778],88:[0,.68333,0,0,.75],89:[0,.68333,.025,0,.75],90:[0,.68333,0,0,.61111],91:[.25,.75,0,0,.27778],92:[.25,.75,0,0,.5],93:[.25,.75,0,0,.27778],94:[0,.69444,0,0,.5],95:[.31,.12056,.02778,0,.5],97:[0,.43056,0,0,.5],98:[0,.69444,0,0,.55556],99:[0,.43056,0,0,.44445],100:[0,.69444,0,0,.55556],101:[0,.43056,0,0,.44445],102:[0,.69444,.07778,0,.30556],103:[.19444,.43056,.01389,0,.5],104:[0,.69444,0,0,.55556],105:[0,.66786,0,0,.27778],106:[.19444,.66786,0,0,.30556],107:[0,.69444,0,0,.52778],108:[0,.69444,0,0,.27778],109:[0,.43056,0,0,.83334],110:[0,.43056,0,0,.55556],111:[0,.43056,0,0,.5],112:[.19444,.43056,0,0,.55556],113:[.19444,.43056,0,0,.52778],114:[0,.43056,0,0,.39167],115:[0,.43056,0,0,.39445],116:[0,.61508,0,0,.38889],117:[0,.43056,0,0,.55556],118:[0,.43056,.01389,0,.52778],119:[0,.43056,.01389,0,.72222],120:[0,.43056,0,0,.52778],121:[.19444,.43056,.01389,0,.52778],122:[0,.43056,0,0,.44445],123:[.25,.75,0,0,.5],124:[.25,.75,0,0,.27778],125:[.25,.75,0,0,.5],126:[.35,.31786,0,0,.5],160:[0,0,0,0,.25],163:[0,.69444,0,0,.76909],167:[.19444,.69444,0,0,.44445],168:[0,.66786,0,0,.5],172:[0,.43056,0,0,.66667],176:[0,.69444,0,0,.75],177:[.08333,.58333,0,0,.77778],182:[.19444,.69444,0,0,.61111],184:[.17014,0,0,0,.44445],198:[0,.68333,0,0,.90278],215:[.08333,.58333,0,0,.77778],216:[.04861,.73194,0,0,.77778],223:[0,.69444,0,0,.5],230:[0,.43056,0,0,.72222],247:[.08333,.58333,0,0,.77778],248:[.09722,.52778,0,0,.5],305:[0,.43056,0,0,.27778],338:[0,.68333,0,0,1.01389],339:[0,.43056,0,0,.77778],567:[.19444,.43056,0,0,.30556],710:[0,.69444,0,0,.5],711:[0,.62847,0,0,.5],713:[0,.56778,0,0,.5],714:[0,.69444,0,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,0,0,.5],729:[0,.66786,0,0,.27778],730:[0,.69444,0,0,.75],732:[0,.66786,0,0,.5],733:[0,.69444,0,0,.5],915:[0,.68333,0,0,.625],916:[0,.68333,0,0,.83334],920:[0,.68333,0,0,.77778],923:[0,.68333,0,0,.69445],926:[0,.68333,0,0,.66667],928:[0,.68333,0,0,.75],931:[0,.68333,0,0,.72222],933:[0,.68333,0,0,.77778],934:[0,.68333,0,0,.72222],936:[0,.68333,0,0,.77778],937:[0,.68333,0,0,.72222],8211:[0,.43056,.02778,0,.5],8212:[0,.43056,.02778,0,1],8216:[0,.69444,0,0,.27778],8217:[0,.69444,0,0,.27778],8220:[0,.69444,0,0,.5],8221:[0,.69444,0,0,.5],8224:[.19444,.69444,0,0,.44445],8225:[.19444,.69444,0,0,.44445],8230:[0,.123,0,0,1.172],8242:[0,.55556,0,0,.275],8407:[0,.71444,.15382,0,.5],8463:[0,.68889,0,0,.54028],8465:[0,.69444,0,0,.72222],8467:[0,.69444,0,.11111,.41667],8472:[.19444,.43056,0,.11111,.63646],8476:[0,.69444,0,0,.72222],8501:[0,.69444,0,0,.61111],8592:[-.13313,.36687,0,0,1],8593:[.19444,.69444,0,0,.5],8594:[-.13313,.36687,0,0,1],8595:[.19444,.69444,0,0,.5],8596:[-.13313,.36687,0,0,1],8597:[.25,.75,0,0,.5],8598:[.19444,.69444,0,0,1],8599:[.19444,.69444,0,0,1],8600:[.19444,.69444,0,0,1],8601:[.19444,.69444,0,0,1],8614:[.011,.511,0,0,1],8617:[.011,.511,0,0,1.126],8618:[.011,.511,0,0,1.126],8636:[-.13313,.36687,0,0,1],8637:[-.13313,.36687,0,0,1],8640:[-.13313,.36687,0,0,1],8641:[-.13313,.36687,0,0,1],8652:[.011,.671,0,0,1],8656:[-.13313,.36687,0,0,1],8657:[.19444,.69444,0,0,.61111],8658:[-.13313,.36687,0,0,1],8659:[.19444,.69444,0,0,.61111],8660:[-.13313,.36687,0,0,1],8661:[.25,.75,0,0,.61111],8704:[0,.69444,0,0,.55556],8706:[0,.69444,.05556,.08334,.5309],8707:[0,.69444,0,0,.55556],8709:[.05556,.75,0,0,.5],8711:[0,.68333,0,0,.83334],8712:[.0391,.5391,0,0,.66667],8715:[.0391,.5391,0,0,.66667],8722:[.08333,.58333,0,0,.77778],8723:[.08333,.58333,0,0,.77778],8725:[.25,.75,0,0,.5],8726:[.25,.75,0,0,.5],8727:[-.03472,.46528,0,0,.5],8728:[-.05555,.44445,0,0,.5],8729:[-.05555,.44445,0,0,.5],8730:[.2,.8,0,0,.83334],8733:[0,.43056,0,0,.77778],8734:[0,.43056,0,0,1],8736:[0,.69224,0,0,.72222],8739:[.25,.75,0,0,.27778],8741:[.25,.75,0,0,.5],8743:[0,.55556,0,0,.66667],8744:[0,.55556,0,0,.66667],8745:[0,.55556,0,0,.66667],8746:[0,.55556,0,0,.66667],8747:[.19444,.69444,.11111,0,.41667],8764:[-.13313,.36687,0,0,.77778],8768:[.19444,.69444,0,0,.27778],8771:[-.03625,.46375,0,0,.77778],8773:[-.022,.589,0,0,.778],8776:[-.01688,.48312,0,0,.77778],8781:[-.03625,.46375,0,0,.77778],8784:[-.133,.673,0,0,.778],8801:[-.03625,.46375,0,0,.77778],8804:[.13597,.63597,0,0,.77778],8805:[.13597,.63597,0,0,.77778],8810:[.0391,.5391,0,0,1],8811:[.0391,.5391,0,0,1],8826:[.0391,.5391,0,0,.77778],8827:[.0391,.5391,0,0,.77778],8834:[.0391,.5391,0,0,.77778],8835:[.0391,.5391,0,0,.77778],8838:[.13597,.63597,0,0,.77778],8839:[.13597,.63597,0,0,.77778],8846:[0,.55556,0,0,.66667],8849:[.13597,.63597,0,0,.77778],8850:[.13597,.63597,0,0,.77778],8851:[0,.55556,0,0,.66667],8852:[0,.55556,0,0,.66667],8853:[.08333,.58333,0,0,.77778],8854:[.08333,.58333,0,0,.77778],8855:[.08333,.58333,0,0,.77778],8856:[.08333,.58333,0,0,.77778],8857:[.08333,.58333,0,0,.77778],8866:[0,.69444,0,0,.61111],8867:[0,.69444,0,0,.61111],8868:[0,.69444,0,0,.77778],8869:[0,.69444,0,0,.77778],8872:[.249,.75,0,0,.867],8900:[-.05555,.44445,0,0,.5],8901:[-.05555,.44445,0,0,.27778],8902:[-.03472,.46528,0,0,.5],8904:[.005,.505,0,0,.9],8942:[.03,.903,0,0,.278],8943:[-.19,.313,0,0,1.172],8945:[-.1,.823,0,0,1.282],8968:[.25,.75,0,0,.44445],8969:[.25,.75,0,0,.44445],8970:[.25,.75,0,0,.44445],8971:[.25,.75,0,0,.44445],8994:[-.14236,.35764,0,0,1],8995:[-.14236,.35764,0,0,1],9136:[.244,.744,0,0,.412],9137:[.244,.745,0,0,.412],9651:[.19444,.69444,0,0,.88889],9657:[-.03472,.46528,0,0,.5],9661:[.19444,.69444,0,0,.88889],9667:[-.03472,.46528,0,0,.5],9711:[.19444,.69444,0,0,1],9824:[.12963,.69444,0,0,.77778],9825:[.12963,.69444,0,0,.77778],9826:[.12963,.69444,0,0,.77778],9827:[.12963,.69444,0,0,.77778],9837:[0,.75,0,0,.38889],9838:[.19444,.69444,0,0,.38889],9839:[.19444,.69444,0,0,.38889],10216:[.25,.75,0,0,.38889],10217:[.25,.75,0,0,.38889],10222:[.244,.744,0,0,.412],10223:[.244,.745,0,0,.412],10229:[.011,.511,0,0,1.609],10230:[.011,.511,0,0,1.638],10231:[.011,.511,0,0,1.859],10232:[.024,.525,0,0,1.609],10233:[.024,.525,0,0,1.638],10234:[.024,.525,0,0,1.858],10236:[.011,.511,0,0,1.638],10815:[0,.68333,0,0,.75],10927:[.13597,.63597,0,0,.77778],10928:[.13597,.63597,0,0,.77778],57376:[.19444,.69444,0,0,0]},"Math-BoldItalic":{32:[0,0,0,0,.25],48:[0,.44444,0,0,.575],49:[0,.44444,0,0,.575],50:[0,.44444,0,0,.575],51:[.19444,.44444,0,0,.575],52:[.19444,.44444,0,0,.575],53:[.19444,.44444,0,0,.575],54:[0,.64444,0,0,.575],55:[.19444,.44444,0,0,.575],56:[0,.64444,0,0,.575],57:[.19444,.44444,0,0,.575],65:[0,.68611,0,0,.86944],66:[0,.68611,.04835,0,.8664],67:[0,.68611,.06979,0,.81694],68:[0,.68611,.03194,0,.93812],69:[0,.68611,.05451,0,.81007],70:[0,.68611,.15972,0,.68889],71:[0,.68611,0,0,.88673],72:[0,.68611,.08229,0,.98229],73:[0,.68611,.07778,0,.51111],74:[0,.68611,.10069,0,.63125],75:[0,.68611,.06979,0,.97118],76:[0,.68611,0,0,.75555],77:[0,.68611,.11424,0,1.14201],78:[0,.68611,.11424,0,.95034],79:[0,.68611,.03194,0,.83666],80:[0,.68611,.15972,0,.72309],81:[.19444,.68611,0,0,.86861],82:[0,.68611,.00421,0,.87235],83:[0,.68611,.05382,0,.69271],84:[0,.68611,.15972,0,.63663],85:[0,.68611,.11424,0,.80027],86:[0,.68611,.25555,0,.67778],87:[0,.68611,.15972,0,1.09305],88:[0,.68611,.07778,0,.94722],89:[0,.68611,.25555,0,.67458],90:[0,.68611,.06979,0,.77257],97:[0,.44444,0,0,.63287],98:[0,.69444,0,0,.52083],99:[0,.44444,0,0,.51342],100:[0,.69444,0,0,.60972],101:[0,.44444,0,0,.55361],102:[.19444,.69444,.11042,0,.56806],103:[.19444,.44444,.03704,0,.5449],104:[0,.69444,0,0,.66759],105:[0,.69326,0,0,.4048],106:[.19444,.69326,.0622,0,.47083],107:[0,.69444,.01852,0,.6037],108:[0,.69444,.0088,0,.34815],109:[0,.44444,0,0,1.0324],110:[0,.44444,0,0,.71296],111:[0,.44444,0,0,.58472],112:[.19444,.44444,0,0,.60092],113:[.19444,.44444,.03704,0,.54213],114:[0,.44444,.03194,0,.5287],115:[0,.44444,0,0,.53125],116:[0,.63492,0,0,.41528],117:[0,.44444,0,0,.68102],118:[0,.44444,.03704,0,.56666],119:[0,.44444,.02778,0,.83148],120:[0,.44444,0,0,.65903],121:[.19444,.44444,.03704,0,.59028],122:[0,.44444,.04213,0,.55509],160:[0,0,0,0,.25],915:[0,.68611,.15972,0,.65694],916:[0,.68611,0,0,.95833],920:[0,.68611,.03194,0,.86722],923:[0,.68611,0,0,.80555],926:[0,.68611,.07458,0,.84125],928:[0,.68611,.08229,0,.98229],931:[0,.68611,.05451,0,.88507],933:[0,.68611,.15972,0,.67083],934:[0,.68611,0,0,.76666],936:[0,.68611,.11653,0,.71402],937:[0,.68611,.04835,0,.8789],945:[0,.44444,0,0,.76064],946:[.19444,.69444,.03403,0,.65972],947:[.19444,.44444,.06389,0,.59003],948:[0,.69444,.03819,0,.52222],949:[0,.44444,0,0,.52882],950:[.19444,.69444,.06215,0,.50833],951:[.19444,.44444,.03704,0,.6],952:[0,.69444,.03194,0,.5618],953:[0,.44444,0,0,.41204],954:[0,.44444,0,0,.66759],955:[0,.69444,0,0,.67083],956:[.19444,.44444,0,0,.70787],957:[0,.44444,.06898,0,.57685],958:[.19444,.69444,.03021,0,.50833],959:[0,.44444,0,0,.58472],960:[0,.44444,.03704,0,.68241],961:[.19444,.44444,0,0,.6118],962:[.09722,.44444,.07917,0,.42361],963:[0,.44444,.03704,0,.68588],964:[0,.44444,.13472,0,.52083],965:[0,.44444,.03704,0,.63055],966:[.19444,.44444,0,0,.74722],967:[.19444,.44444,0,0,.71805],968:[.19444,.69444,.03704,0,.75833],969:[0,.44444,.03704,0,.71782],977:[0,.69444,0,0,.69155],981:[.19444,.69444,0,0,.7125],982:[0,.44444,.03194,0,.975],1009:[.19444,.44444,0,0,.6118],1013:[0,.44444,0,0,.48333],57649:[0,.44444,0,0,.39352],57911:[.19444,.44444,0,0,.43889]},"Math-Italic":{32:[0,0,0,0,.25],48:[0,.43056,0,0,.5],49:[0,.43056,0,0,.5],50:[0,.43056,0,0,.5],51:[.19444,.43056,0,0,.5],52:[.19444,.43056,0,0,.5],53:[.19444,.43056,0,0,.5],54:[0,.64444,0,0,.5],55:[.19444,.43056,0,0,.5],56:[0,.64444,0,0,.5],57:[.19444,.43056,0,0,.5],65:[0,.68333,0,.13889,.75],66:[0,.68333,.05017,.08334,.75851],67:[0,.68333,.07153,.08334,.71472],68:[0,.68333,.02778,.05556,.82792],69:[0,.68333,.05764,.08334,.7382],70:[0,.68333,.13889,.08334,.64306],71:[0,.68333,0,.08334,.78625],72:[0,.68333,.08125,.05556,.83125],73:[0,.68333,.07847,.11111,.43958],74:[0,.68333,.09618,.16667,.55451],75:[0,.68333,.07153,.05556,.84931],76:[0,.68333,0,.02778,.68056],77:[0,.68333,.10903,.08334,.97014],78:[0,.68333,.10903,.08334,.80347],79:[0,.68333,.02778,.08334,.76278],80:[0,.68333,.13889,.08334,.64201],81:[.19444,.68333,0,.08334,.79056],82:[0,.68333,.00773,.08334,.75929],83:[0,.68333,.05764,.08334,.6132],84:[0,.68333,.13889,.08334,.58438],85:[0,.68333,.10903,.02778,.68278],86:[0,.68333,.22222,0,.58333],87:[0,.68333,.13889,0,.94445],88:[0,.68333,.07847,.08334,.82847],89:[0,.68333,.22222,0,.58056],90:[0,.68333,.07153,.08334,.68264],97:[0,.43056,0,0,.52859],98:[0,.69444,0,0,.42917],99:[0,.43056,0,.05556,.43276],100:[0,.69444,0,.16667,.52049],101:[0,.43056,0,.05556,.46563],102:[.19444,.69444,.10764,.16667,.48959],103:[.19444,.43056,.03588,.02778,.47697],104:[0,.69444,0,0,.57616],105:[0,.65952,0,0,.34451],106:[.19444,.65952,.05724,0,.41181],107:[0,.69444,.03148,0,.5206],108:[0,.69444,.01968,.08334,.29838],109:[0,.43056,0,0,.87801],110:[0,.43056,0,0,.60023],111:[0,.43056,0,.05556,.48472],112:[.19444,.43056,0,.08334,.50313],113:[.19444,.43056,.03588,.08334,.44641],114:[0,.43056,.02778,.05556,.45116],115:[0,.43056,0,.05556,.46875],116:[0,.61508,0,.08334,.36111],117:[0,.43056,0,.02778,.57246],118:[0,.43056,.03588,.02778,.48472],119:[0,.43056,.02691,.08334,.71592],120:[0,.43056,0,.02778,.57153],121:[.19444,.43056,.03588,.05556,.49028],122:[0,.43056,.04398,.05556,.46505],160:[0,0,0,0,.25],915:[0,.68333,.13889,.08334,.61528],916:[0,.68333,0,.16667,.83334],920:[0,.68333,.02778,.08334,.76278],923:[0,.68333,0,.16667,.69445],926:[0,.68333,.07569,.08334,.74236],928:[0,.68333,.08125,.05556,.83125],931:[0,.68333,.05764,.08334,.77986],933:[0,.68333,.13889,.05556,.58333],934:[0,.68333,0,.08334,.66667],936:[0,.68333,.11,.05556,.61222],937:[0,.68333,.05017,.08334,.7724],945:[0,.43056,.0037,.02778,.6397],946:[.19444,.69444,.05278,.08334,.56563],947:[.19444,.43056,.05556,0,.51773],948:[0,.69444,.03785,.05556,.44444],949:[0,.43056,0,.08334,.46632],950:[.19444,.69444,.07378,.08334,.4375],951:[.19444,.43056,.03588,.05556,.49653],952:[0,.69444,.02778,.08334,.46944],953:[0,.43056,0,.05556,.35394],954:[0,.43056,0,0,.57616],955:[0,.69444,0,0,.58334],956:[.19444,.43056,0,.02778,.60255],957:[0,.43056,.06366,.02778,.49398],958:[.19444,.69444,.04601,.11111,.4375],959:[0,.43056,0,.05556,.48472],960:[0,.43056,.03588,0,.57003],961:[.19444,.43056,0,.08334,.51702],962:[.09722,.43056,.07986,.08334,.36285],963:[0,.43056,.03588,0,.57141],964:[0,.43056,.1132,.02778,.43715],965:[0,.43056,.03588,.02778,.54028],966:[.19444,.43056,0,.08334,.65417],967:[.19444,.43056,0,.05556,.62569],968:[.19444,.69444,.03588,.11111,.65139],969:[0,.43056,.03588,0,.62245],977:[0,.69444,0,.08334,.59144],981:[.19444,.69444,0,.08334,.59583],982:[0,.43056,.02778,0,.82813],1009:[.19444,.43056,0,.08334,.51702],1013:[0,.43056,0,.05556,.4059],57649:[0,.43056,0,.02778,.32246],57911:[.19444,.43056,0,.08334,.38403]},"SansSerif-Bold":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.36667],34:[0,.69444,0,0,.55834],35:[.19444,.69444,0,0,.91667],36:[.05556,.75,0,0,.55],37:[.05556,.75,0,0,1.02912],38:[0,.69444,0,0,.83056],39:[0,.69444,0,0,.30556],40:[.25,.75,0,0,.42778],41:[.25,.75,0,0,.42778],42:[0,.75,0,0,.55],43:[.11667,.61667,0,0,.85556],44:[.10556,.13056,0,0,.30556],45:[0,.45833,0,0,.36667],46:[0,.13056,0,0,.30556],47:[.25,.75,0,0,.55],48:[0,.69444,0,0,.55],49:[0,.69444,0,0,.55],50:[0,.69444,0,0,.55],51:[0,.69444,0,0,.55],52:[0,.69444,0,0,.55],53:[0,.69444,0,0,.55],54:[0,.69444,0,0,.55],55:[0,.69444,0,0,.55],56:[0,.69444,0,0,.55],57:[0,.69444,0,0,.55],58:[0,.45833,0,0,.30556],59:[.10556,.45833,0,0,.30556],61:[-.09375,.40625,0,0,.85556],63:[0,.69444,0,0,.51945],64:[0,.69444,0,0,.73334],65:[0,.69444,0,0,.73334],66:[0,.69444,0,0,.73334],67:[0,.69444,0,0,.70278],68:[0,.69444,0,0,.79445],69:[0,.69444,0,0,.64167],70:[0,.69444,0,0,.61111],71:[0,.69444,0,0,.73334],72:[0,.69444,0,0,.79445],73:[0,.69444,0,0,.33056],74:[0,.69444,0,0,.51945],75:[0,.69444,0,0,.76389],76:[0,.69444,0,0,.58056],77:[0,.69444,0,0,.97778],78:[0,.69444,0,0,.79445],79:[0,.69444,0,0,.79445],80:[0,.69444,0,0,.70278],81:[.10556,.69444,0,0,.79445],82:[0,.69444,0,0,.70278],83:[0,.69444,0,0,.61111],84:[0,.69444,0,0,.73334],85:[0,.69444,0,0,.76389],86:[0,.69444,.01528,0,.73334],87:[0,.69444,.01528,0,1.03889],88:[0,.69444,0,0,.73334],89:[0,.69444,.0275,0,.73334],90:[0,.69444,0,0,.67223],91:[.25,.75,0,0,.34306],93:[.25,.75,0,0,.34306],94:[0,.69444,0,0,.55],95:[.35,.10833,.03056,0,.55],97:[0,.45833,0,0,.525],98:[0,.69444,0,0,.56111],99:[0,.45833,0,0,.48889],100:[0,.69444,0,0,.56111],101:[0,.45833,0,0,.51111],102:[0,.69444,.07639,0,.33611],103:[.19444,.45833,.01528,0,.55],104:[0,.69444,0,0,.56111],105:[0,.69444,0,0,.25556],106:[.19444,.69444,0,0,.28611],107:[0,.69444,0,0,.53056],108:[0,.69444,0,0,.25556],109:[0,.45833,0,0,.86667],110:[0,.45833,0,0,.56111],111:[0,.45833,0,0,.55],112:[.19444,.45833,0,0,.56111],113:[.19444,.45833,0,0,.56111],114:[0,.45833,.01528,0,.37222],115:[0,.45833,0,0,.42167],116:[0,.58929,0,0,.40417],117:[0,.45833,0,0,.56111],118:[0,.45833,.01528,0,.5],119:[0,.45833,.01528,0,.74445],120:[0,.45833,0,0,.5],121:[.19444,.45833,.01528,0,.5],122:[0,.45833,0,0,.47639],126:[.35,.34444,0,0,.55],160:[0,0,0,0,.25],168:[0,.69444,0,0,.55],176:[0,.69444,0,0,.73334],180:[0,.69444,0,0,.55],184:[.17014,0,0,0,.48889],305:[0,.45833,0,0,.25556],567:[.19444,.45833,0,0,.28611],710:[0,.69444,0,0,.55],711:[0,.63542,0,0,.55],713:[0,.63778,0,0,.55],728:[0,.69444,0,0,.55],729:[0,.69444,0,0,.30556],730:[0,.69444,0,0,.73334],732:[0,.69444,0,0,.55],733:[0,.69444,0,0,.55],915:[0,.69444,0,0,.58056],916:[0,.69444,0,0,.91667],920:[0,.69444,0,0,.85556],923:[0,.69444,0,0,.67223],926:[0,.69444,0,0,.73334],928:[0,.69444,0,0,.79445],931:[0,.69444,0,0,.79445],933:[0,.69444,0,0,.85556],934:[0,.69444,0,0,.79445],936:[0,.69444,0,0,.85556],937:[0,.69444,0,0,.79445],8211:[0,.45833,.03056,0,.55],8212:[0,.45833,.03056,0,1.10001],8216:[0,.69444,0,0,.30556],8217:[0,.69444,0,0,.30556],8220:[0,.69444,0,0,.55834],8221:[0,.69444,0,0,.55834]},"SansSerif-Italic":{32:[0,0,0,0,.25],33:[0,.69444,.05733,0,.31945],34:[0,.69444,.00316,0,.5],35:[.19444,.69444,.05087,0,.83334],36:[.05556,.75,.11156,0,.5],37:[.05556,.75,.03126,0,.83334],38:[0,.69444,.03058,0,.75834],39:[0,.69444,.07816,0,.27778],40:[.25,.75,.13164,0,.38889],41:[.25,.75,.02536,0,.38889],42:[0,.75,.11775,0,.5],43:[.08333,.58333,.02536,0,.77778],44:[.125,.08333,0,0,.27778],45:[0,.44444,.01946,0,.33333],46:[0,.08333,0,0,.27778],47:[.25,.75,.13164,0,.5],48:[0,.65556,.11156,0,.5],49:[0,.65556,.11156,0,.5],50:[0,.65556,.11156,0,.5],51:[0,.65556,.11156,0,.5],52:[0,.65556,.11156,0,.5],53:[0,.65556,.11156,0,.5],54:[0,.65556,.11156,0,.5],55:[0,.65556,.11156,0,.5],56:[0,.65556,.11156,0,.5],57:[0,.65556,.11156,0,.5],58:[0,.44444,.02502,0,.27778],59:[.125,.44444,.02502,0,.27778],61:[-.13,.37,.05087,0,.77778],63:[0,.69444,.11809,0,.47222],64:[0,.69444,.07555,0,.66667],65:[0,.69444,0,0,.66667],66:[0,.69444,.08293,0,.66667],67:[0,.69444,.11983,0,.63889],68:[0,.69444,.07555,0,.72223],69:[0,.69444,.11983,0,.59722],70:[0,.69444,.13372,0,.56945],71:[0,.69444,.11983,0,.66667],72:[0,.69444,.08094,0,.70834],73:[0,.69444,.13372,0,.27778],74:[0,.69444,.08094,0,.47222],75:[0,.69444,.11983,0,.69445],76:[0,.69444,0,0,.54167],77:[0,.69444,.08094,0,.875],78:[0,.69444,.08094,0,.70834],79:[0,.69444,.07555,0,.73611],80:[0,.69444,.08293,0,.63889],81:[.125,.69444,.07555,0,.73611],82:[0,.69444,.08293,0,.64584],83:[0,.69444,.09205,0,.55556],84:[0,.69444,.13372,0,.68056],85:[0,.69444,.08094,0,.6875],86:[0,.69444,.1615,0,.66667],87:[0,.69444,.1615,0,.94445],88:[0,.69444,.13372,0,.66667],89:[0,.69444,.17261,0,.66667],90:[0,.69444,.11983,0,.61111],91:[.25,.75,.15942,0,.28889],93:[.25,.75,.08719,0,.28889],94:[0,.69444,.0799,0,.5],95:[.35,.09444,.08616,0,.5],97:[0,.44444,.00981,0,.48056],98:[0,.69444,.03057,0,.51667],99:[0,.44444,.08336,0,.44445],100:[0,.69444,.09483,0,.51667],101:[0,.44444,.06778,0,.44445],102:[0,.69444,.21705,0,.30556],103:[.19444,.44444,.10836,0,.5],104:[0,.69444,.01778,0,.51667],105:[0,.67937,.09718,0,.23889],106:[.19444,.67937,.09162,0,.26667],107:[0,.69444,.08336,0,.48889],108:[0,.69444,.09483,0,.23889],109:[0,.44444,.01778,0,.79445],110:[0,.44444,.01778,0,.51667],111:[0,.44444,.06613,0,.5],112:[.19444,.44444,.0389,0,.51667],113:[.19444,.44444,.04169,0,.51667],114:[0,.44444,.10836,0,.34167],115:[0,.44444,.0778,0,.38333],116:[0,.57143,.07225,0,.36111],117:[0,.44444,.04169,0,.51667],118:[0,.44444,.10836,0,.46111],119:[0,.44444,.10836,0,.68334],120:[0,.44444,.09169,0,.46111],121:[.19444,.44444,.10836,0,.46111],122:[0,.44444,.08752,0,.43472],126:[.35,.32659,.08826,0,.5],160:[0,0,0,0,.25],168:[0,.67937,.06385,0,.5],176:[0,.69444,0,0,.73752],184:[.17014,0,0,0,.44445],305:[0,.44444,.04169,0,.23889],567:[.19444,.44444,.04169,0,.26667],710:[0,.69444,.0799,0,.5],711:[0,.63194,.08432,0,.5],713:[0,.60889,.08776,0,.5],714:[0,.69444,.09205,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,.09483,0,.5],729:[0,.67937,.07774,0,.27778],730:[0,.69444,0,0,.73752],732:[0,.67659,.08826,0,.5],733:[0,.69444,.09205,0,.5],915:[0,.69444,.13372,0,.54167],916:[0,.69444,0,0,.83334],920:[0,.69444,.07555,0,.77778],923:[0,.69444,0,0,.61111],926:[0,.69444,.12816,0,.66667],928:[0,.69444,.08094,0,.70834],931:[0,.69444,.11983,0,.72222],933:[0,.69444,.09031,0,.77778],934:[0,.69444,.04603,0,.72222],936:[0,.69444,.09031,0,.77778],937:[0,.69444,.08293,0,.72222],8211:[0,.44444,.08616,0,.5],8212:[0,.44444,.08616,0,1],8216:[0,.69444,.07816,0,.27778],8217:[0,.69444,.07816,0,.27778],8220:[0,.69444,.14205,0,.5],8221:[0,.69444,.00316,0,.5]},"SansSerif-Regular":{32:[0,0,0,0,.25],33:[0,.69444,0,0,.31945],34:[0,.69444,0,0,.5],35:[.19444,.69444,0,0,.83334],36:[.05556,.75,0,0,.5],37:[.05556,.75,0,0,.83334],38:[0,.69444,0,0,.75834],39:[0,.69444,0,0,.27778],40:[.25,.75,0,0,.38889],41:[.25,.75,0,0,.38889],42:[0,.75,0,0,.5],43:[.08333,.58333,0,0,.77778],44:[.125,.08333,0,0,.27778],45:[0,.44444,0,0,.33333],46:[0,.08333,0,0,.27778],47:[.25,.75,0,0,.5],48:[0,.65556,0,0,.5],49:[0,.65556,0,0,.5],50:[0,.65556,0,0,.5],51:[0,.65556,0,0,.5],52:[0,.65556,0,0,.5],53:[0,.65556,0,0,.5],54:[0,.65556,0,0,.5],55:[0,.65556,0,0,.5],56:[0,.65556,0,0,.5],57:[0,.65556,0,0,.5],58:[0,.44444,0,0,.27778],59:[.125,.44444,0,0,.27778],61:[-.13,.37,0,0,.77778],63:[0,.69444,0,0,.47222],64:[0,.69444,0,0,.66667],65:[0,.69444,0,0,.66667],66:[0,.69444,0,0,.66667],67:[0,.69444,0,0,.63889],68:[0,.69444,0,0,.72223],69:[0,.69444,0,0,.59722],70:[0,.69444,0,0,.56945],71:[0,.69444,0,0,.66667],72:[0,.69444,0,0,.70834],73:[0,.69444,0,0,.27778],74:[0,.69444,0,0,.47222],75:[0,.69444,0,0,.69445],76:[0,.69444,0,0,.54167],77:[0,.69444,0,0,.875],78:[0,.69444,0,0,.70834],79:[0,.69444,0,0,.73611],80:[0,.69444,0,0,.63889],81:[.125,.69444,0,0,.73611],82:[0,.69444,0,0,.64584],83:[0,.69444,0,0,.55556],84:[0,.69444,0,0,.68056],85:[0,.69444,0,0,.6875],86:[0,.69444,.01389,0,.66667],87:[0,.69444,.01389,0,.94445],88:[0,.69444,0,0,.66667],89:[0,.69444,.025,0,.66667],90:[0,.69444,0,0,.61111],91:[.25,.75,0,0,.28889],93:[.25,.75,0,0,.28889],94:[0,.69444,0,0,.5],95:[.35,.09444,.02778,0,.5],97:[0,.44444,0,0,.48056],98:[0,.69444,0,0,.51667],99:[0,.44444,0,0,.44445],100:[0,.69444,0,0,.51667],101:[0,.44444,0,0,.44445],102:[0,.69444,.06944,0,.30556],103:[.19444,.44444,.01389,0,.5],104:[0,.69444,0,0,.51667],105:[0,.67937,0,0,.23889],106:[.19444,.67937,0,0,.26667],107:[0,.69444,0,0,.48889],108:[0,.69444,0,0,.23889],109:[0,.44444,0,0,.79445],110:[0,.44444,0,0,.51667],111:[0,.44444,0,0,.5],112:[.19444,.44444,0,0,.51667],113:[.19444,.44444,0,0,.51667],114:[0,.44444,.01389,0,.34167],115:[0,.44444,0,0,.38333],116:[0,.57143,0,0,.36111],117:[0,.44444,0,0,.51667],118:[0,.44444,.01389,0,.46111],119:[0,.44444,.01389,0,.68334],120:[0,.44444,0,0,.46111],121:[.19444,.44444,.01389,0,.46111],122:[0,.44444,0,0,.43472],126:[.35,.32659,0,0,.5],160:[0,0,0,0,.25],168:[0,.67937,0,0,.5],176:[0,.69444,0,0,.66667],184:[.17014,0,0,0,.44445],305:[0,.44444,0,0,.23889],567:[.19444,.44444,0,0,.26667],710:[0,.69444,0,0,.5],711:[0,.63194,0,0,.5],713:[0,.60889,0,0,.5],714:[0,.69444,0,0,.5],715:[0,.69444,0,0,.5],728:[0,.69444,0,0,.5],729:[0,.67937,0,0,.27778],730:[0,.69444,0,0,.66667],732:[0,.67659,0,0,.5],733:[0,.69444,0,0,.5],915:[0,.69444,0,0,.54167],916:[0,.69444,0,0,.83334],920:[0,.69444,0,0,.77778],923:[0,.69444,0,0,.61111],926:[0,.69444,0,0,.66667],928:[0,.69444,0,0,.70834],931:[0,.69444,0,0,.72222],933:[0,.69444,0,0,.77778],934:[0,.69444,0,0,.72222],936:[0,.69444,0,0,.77778],937:[0,.69444,0,0,.72222],8211:[0,.44444,.02778,0,.5],8212:[0,.44444,.02778,0,1],8216:[0,.69444,0,0,.27778],8217:[0,.69444,0,0,.27778],8220:[0,.69444,0,0,.5],8221:[0,.69444,0,0,.5]},"Script-Regular":{32:[0,0,0,0,.25],65:[0,.7,.22925,0,.80253],66:[0,.7,.04087,0,.90757],67:[0,.7,.1689,0,.66619],68:[0,.7,.09371,0,.77443],69:[0,.7,.18583,0,.56162],70:[0,.7,.13634,0,.89544],71:[0,.7,.17322,0,.60961],72:[0,.7,.29694,0,.96919],73:[0,.7,.19189,0,.80907],74:[.27778,.7,.19189,0,1.05159],75:[0,.7,.31259,0,.91364],76:[0,.7,.19189,0,.87373],77:[0,.7,.15981,0,1.08031],78:[0,.7,.3525,0,.9015],79:[0,.7,.08078,0,.73787],80:[0,.7,.08078,0,1.01262],81:[0,.7,.03305,0,.88282],82:[0,.7,.06259,0,.85],83:[0,.7,.19189,0,.86767],84:[0,.7,.29087,0,.74697],85:[0,.7,.25815,0,.79996],86:[0,.7,.27523,0,.62204],87:[0,.7,.27523,0,.80532],88:[0,.7,.26006,0,.94445],89:[0,.7,.2939,0,.70961],90:[0,.7,.24037,0,.8212],160:[0,0,0,0,.25]},"Size1-Regular":{32:[0,0,0,0,.25],40:[.35001,.85,0,0,.45834],41:[.35001,.85,0,0,.45834],47:[.35001,.85,0,0,.57778],91:[.35001,.85,0,0,.41667],92:[.35001,.85,0,0,.57778],93:[.35001,.85,0,0,.41667],123:[.35001,.85,0,0,.58334],125:[.35001,.85,0,0,.58334],160:[0,0,0,0,.25],710:[0,.72222,0,0,.55556],732:[0,.72222,0,0,.55556],770:[0,.72222,0,0,.55556],771:[0,.72222,0,0,.55556],8214:[-99e-5,.601,0,0,.77778],8593:[1e-5,.6,0,0,.66667],8595:[1e-5,.6,0,0,.66667],8657:[1e-5,.6,0,0,.77778],8659:[1e-5,.6,0,0,.77778],8719:[.25001,.75,0,0,.94445],8720:[.25001,.75,0,0,.94445],8721:[.25001,.75,0,0,1.05556],8730:[.35001,.85,0,0,1],8739:[-.00599,.606,0,0,.33333],8741:[-.00599,.606,0,0,.55556],8747:[.30612,.805,.19445,0,.47222],8748:[.306,.805,.19445,0,.47222],8749:[.306,.805,.19445,0,.47222],8750:[.30612,.805,.19445,0,.47222],8896:[.25001,.75,0,0,.83334],8897:[.25001,.75,0,0,.83334],8898:[.25001,.75,0,0,.83334],8899:[.25001,.75,0,0,.83334],8968:[.35001,.85,0,0,.47222],8969:[.35001,.85,0,0,.47222],8970:[.35001,.85,0,0,.47222],8971:[.35001,.85,0,0,.47222],9168:[-99e-5,.601,0,0,.66667],10216:[.35001,.85,0,0,.47222],10217:[.35001,.85,0,0,.47222],10752:[.25001,.75,0,0,1.11111],10753:[.25001,.75,0,0,1.11111],10754:[.25001,.75,0,0,1.11111],10756:[.25001,.75,0,0,.83334],10758:[.25001,.75,0,0,.83334]},"Size2-Regular":{32:[0,0,0,0,.25],40:[.65002,1.15,0,0,.59722],41:[.65002,1.15,0,0,.59722],47:[.65002,1.15,0,0,.81111],91:[.65002,1.15,0,0,.47222],92:[.65002,1.15,0,0,.81111],93:[.65002,1.15,0,0,.47222],123:[.65002,1.15,0,0,.66667],125:[.65002,1.15,0,0,.66667],160:[0,0,0,0,.25],710:[0,.75,0,0,1],732:[0,.75,0,0,1],770:[0,.75,0,0,1],771:[0,.75,0,0,1],8719:[.55001,1.05,0,0,1.27778],8720:[.55001,1.05,0,0,1.27778],8721:[.55001,1.05,0,0,1.44445],8730:[.65002,1.15,0,0,1],8747:[.86225,1.36,.44445,0,.55556],8748:[.862,1.36,.44445,0,.55556],8749:[.862,1.36,.44445,0,.55556],8750:[.86225,1.36,.44445,0,.55556],8896:[.55001,1.05,0,0,1.11111],8897:[.55001,1.05,0,0,1.11111],8898:[.55001,1.05,0,0,1.11111],8899:[.55001,1.05,0,0,1.11111],8968:[.65002,1.15,0,0,.52778],8969:[.65002,1.15,0,0,.52778],8970:[.65002,1.15,0,0,.52778],8971:[.65002,1.15,0,0,.52778],10216:[.65002,1.15,0,0,.61111],10217:[.65002,1.15,0,0,.61111],10752:[.55001,1.05,0,0,1.51112],10753:[.55001,1.05,0,0,1.51112],10754:[.55001,1.05,0,0,1.51112],10756:[.55001,1.05,0,0,1.11111],10758:[.55001,1.05,0,0,1.11111]},"Size3-Regular":{32:[0,0,0,0,.25],40:[.95003,1.45,0,0,.73611],41:[.95003,1.45,0,0,.73611],47:[.95003,1.45,0,0,1.04445],91:[.95003,1.45,0,0,.52778],92:[.95003,1.45,0,0,1.04445],93:[.95003,1.45,0,0,.52778],123:[.95003,1.45,0,0,.75],125:[.95003,1.45,0,0,.75],160:[0,0,0,0,.25],710:[0,.75,0,0,1.44445],732:[0,.75,0,0,1.44445],770:[0,.75,0,0,1.44445],771:[0,.75,0,0,1.44445],8730:[.95003,1.45,0,0,1],8968:[.95003,1.45,0,0,.58334],8969:[.95003,1.45,0,0,.58334],8970:[.95003,1.45,0,0,.58334],8971:[.95003,1.45,0,0,.58334],10216:[.95003,1.45,0,0,.75],10217:[.95003,1.45,0,0,.75]},"Size4-Regular":{32:[0,0,0,0,.25],40:[1.25003,1.75,0,0,.79167],41:[1.25003,1.75,0,0,.79167],47:[1.25003,1.75,0,0,1.27778],91:[1.25003,1.75,0,0,.58334],92:[1.25003,1.75,0,0,1.27778],93:[1.25003,1.75,0,0,.58334],123:[1.25003,1.75,0,0,.80556],125:[1.25003,1.75,0,0,.80556],160:[0,0,0,0,.25],710:[0,.825,0,0,1.8889],732:[0,.825,0,0,1.8889],770:[0,.825,0,0,1.8889],771:[0,.825,0,0,1.8889],8730:[1.25003,1.75,0,0,1],8968:[1.25003,1.75,0,0,.63889],8969:[1.25003,1.75,0,0,.63889],8970:[1.25003,1.75,0,0,.63889],8971:[1.25003,1.75,0,0,.63889],9115:[.64502,1.155,0,0,.875],9116:[1e-5,.6,0,0,.875],9117:[.64502,1.155,0,0,.875],9118:[.64502,1.155,0,0,.875],9119:[1e-5,.6,0,0,.875],9120:[.64502,1.155,0,0,.875],9121:[.64502,1.155,0,0,.66667],9122:[-99e-5,.601,0,0,.66667],9123:[.64502,1.155,0,0,.66667],9124:[.64502,1.155,0,0,.66667],9125:[-99e-5,.601,0,0,.66667],9126:[.64502,1.155,0,0,.66667],9127:[1e-5,.9,0,0,.88889],9128:[.65002,1.15,0,0,.88889],9129:[.90001,0,0,0,.88889],9130:[0,.3,0,0,.88889],9131:[1e-5,.9,0,0,.88889],9132:[.65002,1.15,0,0,.88889],9133:[.90001,0,0,0,.88889],9143:[.88502,.915,0,0,1.05556],10216:[1.25003,1.75,0,0,.80556],10217:[1.25003,1.75,0,0,.80556],57344:[-.00499,.605,0,0,1.05556],57345:[-.00499,.605,0,0,1.05556],57680:[0,.12,0,0,.45],57681:[0,.12,0,0,.45],57682:[0,.12,0,0,.45],57683:[0,.12,0,0,.45]},"Typewriter-Regular":{32:[0,0,0,0,.525],33:[0,.61111,0,0,.525],34:[0,.61111,0,0,.525],35:[0,.61111,0,0,.525],36:[.08333,.69444,0,0,.525],37:[.08333,.69444,0,0,.525],38:[0,.61111,0,0,.525],39:[0,.61111,0,0,.525],40:[.08333,.69444,0,0,.525],41:[.08333,.69444,0,0,.525],42:[0,.52083,0,0,.525],43:[-.08056,.53055,0,0,.525],44:[.13889,.125,0,0,.525],45:[-.08056,.53055,0,0,.525],46:[0,.125,0,0,.525],47:[.08333,.69444,0,0,.525],48:[0,.61111,0,0,.525],49:[0,.61111,0,0,.525],50:[0,.61111,0,0,.525],51:[0,.61111,0,0,.525],52:[0,.61111,0,0,.525],53:[0,.61111,0,0,.525],54:[0,.61111,0,0,.525],55:[0,.61111,0,0,.525],56:[0,.61111,0,0,.525],57:[0,.61111,0,0,.525],58:[0,.43056,0,0,.525],59:[.13889,.43056,0,0,.525],60:[-.05556,.55556,0,0,.525],61:[-.19549,.41562,0,0,.525],62:[-.05556,.55556,0,0,.525],63:[0,.61111,0,0,.525],64:[0,.61111,0,0,.525],65:[0,.61111,0,0,.525],66:[0,.61111,0,0,.525],67:[0,.61111,0,0,.525],68:[0,.61111,0,0,.525],69:[0,.61111,0,0,.525],70:[0,.61111,0,0,.525],71:[0,.61111,0,0,.525],72:[0,.61111,0,0,.525],73:[0,.61111,0,0,.525],74:[0,.61111,0,0,.525],75:[0,.61111,0,0,.525],76:[0,.61111,0,0,.525],77:[0,.61111,0,0,.525],78:[0,.61111,0,0,.525],79:[0,.61111,0,0,.525],80:[0,.61111,0,0,.525],81:[.13889,.61111,0,0,.525],82:[0,.61111,0,0,.525],83:[0,.61111,0,0,.525],84:[0,.61111,0,0,.525],85:[0,.61111,0,0,.525],86:[0,.61111,0,0,.525],87:[0,.61111,0,0,.525],88:[0,.61111,0,0,.525],89:[0,.61111,0,0,.525],90:[0,.61111,0,0,.525],91:[.08333,.69444,0,0,.525],92:[.08333,.69444,0,0,.525],93:[.08333,.69444,0,0,.525],94:[0,.61111,0,0,.525],95:[.09514,0,0,0,.525],96:[0,.61111,0,0,.525],97:[0,.43056,0,0,.525],98:[0,.61111,0,0,.525],99:[0,.43056,0,0,.525],100:[0,.61111,0,0,.525],101:[0,.43056,0,0,.525],102:[0,.61111,0,0,.525],103:[.22222,.43056,0,0,.525],104:[0,.61111,0,0,.525],105:[0,.61111,0,0,.525],106:[.22222,.61111,0,0,.525],107:[0,.61111,0,0,.525],108:[0,.61111,0,0,.525],109:[0,.43056,0,0,.525],110:[0,.43056,0,0,.525],111:[0,.43056,0,0,.525],112:[.22222,.43056,0,0,.525],113:[.22222,.43056,0,0,.525],114:[0,.43056,0,0,.525],115:[0,.43056,0,0,.525],116:[0,.55358,0,0,.525],117:[0,.43056,0,0,.525],118:[0,.43056,0,0,.525],119:[0,.43056,0,0,.525],120:[0,.43056,0,0,.525],121:[.22222,.43056,0,0,.525],122:[0,.43056,0,0,.525],123:[.08333,.69444,0,0,.525],124:[.08333,.69444,0,0,.525],125:[.08333,.69444,0,0,.525],126:[0,.61111,0,0,.525],127:[0,.61111,0,0,.525],160:[0,0,0,0,.525],176:[0,.61111,0,0,.525],184:[.19445,0,0,0,.525],305:[0,.43056,0,0,.525],567:[.22222,.43056,0,0,.525],711:[0,.56597,0,0,.525],713:[0,.56555,0,0,.525],714:[0,.61111,0,0,.525],715:[0,.61111,0,0,.525],728:[0,.61111,0,0,.525],730:[0,.61111,0,0,.525],770:[0,.61111,0,0,.525],771:[0,.61111,0,0,.525],776:[0,.61111,0,0,.525],915:[0,.61111,0,0,.525],916:[0,.61111,0,0,.525],920:[0,.61111,0,0,.525],923:[0,.61111,0,0,.525],926:[0,.61111,0,0,.525],928:[0,.61111,0,0,.525],931:[0,.61111,0,0,.525],933:[0,.61111,0,0,.525],934:[0,.61111,0,0,.525],936:[0,.61111,0,0,.525],937:[0,.61111,0,0,.525],8216:[0,.61111,0,0,.525],8217:[0,.61111,0,0,.525],8242:[0,.61111,0,0,.525],9251:[.11111,.21944,0,0,.525]}};const B={slant:[.25,.25,.25],space:[0,0,0],stretch:[0,0,0],shrink:[0,0,0],xHeight:[.431,.431,.431],quad:[1,1.171,1.472],extraSpace:[0,0,0],num1:[.677,.732,.925],num2:[.394,.384,.387],num3:[.444,.471,.504],denom1:[.686,.752,1.025],denom2:[.345,.344,.532],sup1:[.413,.503,.504],sup2:[.363,.431,.404],sup3:[.289,.286,.294],sub1:[.15,.143,.2],sub2:[.247,.286,.4],supDrop:[.386,.353,.494],subDrop:[.05,.071,.1],delim1:[2.39,1.7,1.98],delim2:[1.01,1.157,1.42],axisHeight:[.25,.25,.25],defaultRuleThickness:[.04,.049,.049],bigOpSpacing1:[.111,.111,.111],bigOpSpacing2:[.166,.166,.166],bigOpSpacing3:[.2,.2,.2],bigOpSpacing4:[.6,.611,.611],bigOpSpacing5:[.1,.143,.143],sqrtRuleThickness:[.04,.04,.04],ptPerEm:[10,10,10],doubleRuleSep:[.2,.2,.2],arrayRuleWidth:[.04,.04,.04],fboxsep:[.3,.3,.3],fboxrule:[.04,.04,.04]},C={"\xc5":"A","\xd0":"D","\xde":"o","\xe5":"a","\xf0":"d","\xfe":"o","\u0410":"A","\u0411":"B","\u0412":"B","\u0413":"F","\u0414":"A","\u0415":"E","\u0416":"K","\u0417":"3","\u0418":"N","\u0419":"N","\u041a":"K","\u041b":"N","\u041c":"M","\u041d":"H","\u041e":"O","\u041f":"N","\u0420":"P","\u0421":"C","\u0422":"T","\u0423":"y","\u0424":"O","\u0425":"X","\u0426":"U","\u0427":"h","\u0428":"W","\u0429":"W","\u042a":"B","\u042b":"X","\u042c":"B","\u042d":"3","\u042e":"X","\u042f":"R","\u0430":"a","\u0431":"b","\u0432":"a","\u0433":"r","\u0434":"y","\u0435":"e","\u0436":"m","\u0437":"e","\u0438":"n","\u0439":"n","\u043a":"n","\u043b":"n","\u043c":"m","\u043d":"n","\u043e":"o","\u043f":"n","\u0440":"p","\u0441":"c","\u0442":"o","\u0443":"y","\u0444":"b","\u0445":"x","\u0446":"n","\u0447":"n","\u0448":"w","\u0449":"w","\u044a":"a","\u044b":"m","\u044c":"a","\u044d":"e","\u044e":"m","\u044f":"r"};function N(e,t,r){if(!T[t])throw new Error("Font metrics not found for font: "+t+".");let n=e.charCodeAt(0),o=T[t][n];if(!o&&e[0]in C&&(n=C[e[0]].charCodeAt(0),o=T[t][n]),o||"text"!==r||S(n)&&(o=T[t][77]),o)return{depth:o[0],height:o[1],italic:o[2],skew:o[3],width:o[4]}}const q={};const I=[[1,1,1],[2,1,1],[3,1,1],[4,2,1],[5,2,1],[6,3,1],[7,4,2],[8,6,3],[9,7,6],[10,8,7],[11,10,9]],R=[.5,.6,.7,.8,.9,1,1.2,1.44,1.728,2.074,2.488],H=function(e,t){return t.size<2?e:I[e-1][t.size-1]};class O{constructor(e){this.style=void 0,this.color=void 0,this.size=void 0,this.textSize=void 0,this.phantom=void 0,this.font=void 0,this.fontFamily=void 0,this.fontWeight=void 0,this.fontShape=void 0,this.sizeMultiplier=void 0,this.maxSize=void 0,this.minRuleThickness=void 0,this._fontMetrics=void 0,this.style=e.style,this.color=e.color,this.size=e.size||O.BASESIZE,this.textSize=e.textSize||this.size,this.phantom=!!e.phantom,this.font=e.font||"",this.fontFamily=e.fontFamily||"",this.fontWeight=e.fontWeight||"",this.fontShape=e.fontShape||"",this.sizeMultiplier=R[this.size-1],this.maxSize=e.maxSize,this.minRuleThickness=e.minRuleThickness,this._fontMetrics=void 0}extend(e){const t={style:this.style,size:this.size,textSize:this.textSize,color:this.color,phantom:this.phantom,font:this.font,fontFamily:this.fontFamily,fontWeight:this.fontWeight,fontShape:this.fontShape,maxSize:this.maxSize,minRuleThickness:this.minRuleThickness};for(const r in e)e.hasOwnProperty(r)&&(t[r]=e[r]);return new O(t)}havingStyle(e){return this.style===e?this:this.extend({style:e,size:H(this.textSize,e)})}havingCrampedStyle(){return this.havingStyle(this.style.cramp())}havingSize(e){return this.size===e&&this.textSize===e?this:this.extend({style:this.style.text(),size:e,textSize:e,sizeMultiplier:R[e-1]})}havingBaseStyle(e){e=e||this.style.text();const t=H(O.BASESIZE,e);return this.size===t&&this.textSize===O.BASESIZE&&this.style===e?this:this.extend({style:e,size:t})}havingBaseSizing(){let e;switch(this.style.id){case 4:case 5:e=3;break;case 6:case 7:e=1;break;default:e=6}return this.extend({style:this.style.text(),size:e})}withColor(e){return this.extend({color:e})}withPhantom(){return this.extend({phantom:!0})}withFont(e){return this.extend({font:e})}withTextFontFamily(e){return this.extend({fontFamily:e,font:""})}withTextFontWeight(e){return this.extend({fontWeight:e,font:""})}withTextFontShape(e){return this.extend({fontShape:e,font:""})}sizingClasses(e){return e.size!==this.size?["sizing","reset-size"+e.size,"size"+this.size]:[]}baseSizingClasses(){return this.size!==O.BASESIZE?["sizing","reset-size"+this.size,"size"+O.BASESIZE]:[]}fontMetrics(){return this._fontMetrics||(this._fontMetrics=function(e){let t;if(t=e>=5?0:e>=3?1:2,!q[t]){const e=q[t]={cssEmPerMu:B.quad[t]/18};for(const r in B)B.hasOwnProperty(r)&&(e[r]=B[r][t])}return q[t]}(this.size)),this._fontMetrics}getColor(){return this.phantom?"transparent":this.color}}O.BASESIZE=6;var E=O;const L={pt:1,mm:7227/2540,cm:7227/254,in:72.27,bp:1.00375,pc:12,dd:1238/1157,cc:14856/1157,nd:685/642,nc:1370/107,sp:1/65536,px:1.00375},D={ex:!0,em:!0,mu:!0},V=function(e){return"string"!=typeof e&&(e=e.unit),e in L||e in D||"ex"===e},P=function(e,t){let r;if(e.unit in L)r=L[e.unit]/t.fontMetrics().ptPerEm/t.sizeMultiplier;else if("mu"===e.unit)r=t.fontMetrics().cssEmPerMu;else{let o;if(o=t.style.isTight()?t.havingStyle(t.style.text()):t,"ex"===e.unit)r=o.fontMetrics().xHeight;else{if("em"!==e.unit)throw new n("Invalid unit: '"+e.unit+"'");r=o.fontMetrics().quad}o!==t&&(r*=o.sizeMultiplier/t.sizeMultiplier)}return Math.min(e.number*r,t.maxSize)},F=function(e){return+e.toFixed(4)+"em"},G=function(e){return e.filter((e=>e)).join(" ")},U=function(e,t,r){if(this.classes=e||[],this.attributes={},this.height=0,this.depth=0,this.maxFontSize=0,this.style=r||{},t){t.style.isTight()&&this.classes.push("mtight");const e=t.getColor();e&&(this.style.color=e)}},Y=function(e){const t=document.createElement(e);t.className=G(this.classes);for(const e in this.style)this.style.hasOwnProperty(e)&&(t.style[e]=this.style[e]);for(const e in this.attributes)this.attributes.hasOwnProperty(e)&&t.setAttribute(e,this.attributes[e]);for(let e=0;e<this.children.length;e++)t.appendChild(this.children[e].toNode());return t},X=/[\s"'>/=\x00-\x1f]/,W=function(e){let t="<"+e;this.classes.length&&(t+=' class="'+l.escape(G(this.classes))+'"');let r="";for(const e in this.style)this.style.hasOwnProperty(e)&&(r+=l.hyphenate(e)+":"+this.style[e]+";");r&&(t+=' style="'+l.escape(r)+'"');for(const e in this.attributes)if(this.attributes.hasOwnProperty(e)){if(X.test(e))throw new n("Invalid attribute name '"+e+"'");t+=" "+e+'="'+l.escape(this.attributes[e])+'"'}t+=">";for(let e=0;e<this.children.length;e++)t+=this.children[e].toMarkup();return t+="</"+e+">",t};class _{constructor(e,t,r,n){this.children=void 0,this.attributes=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.width=void 0,this.maxFontSize=void 0,this.style=void 0,U.call(this,e,r,n),this.children=t||[]}setAttribute(e,t){this.attributes[e]=t}hasClass(e){return l.contains(this.classes,e)}toNode(){return Y.call(this,"span")}toMarkup(){return W.call(this,"span")}}class j{constructor(e,t,r,n){this.children=void 0,this.attributes=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,U.call(this,t,n),this.children=r||[],this.setAttribute("href",e)}setAttribute(e,t){this.attributes[e]=t}hasClass(e){return l.contains(this.classes,e)}toNode(){return Y.call(this,"a")}toMarkup(){return W.call(this,"a")}}class ${constructor(e,t,r){this.src=void 0,this.alt=void 0,this.classes=void 0,this.height=void 0,this.depth=void 0,this.maxFontSize=void 0,this.style=void 0,this.alt=t,this.src=e,this.classes=["mord"],this.style=r}hasClass(e){return l.contains(this.classes,e)}toNode(){const e=document.createElement("img");e.src=this.src,e.alt=this.alt,e.className="mord";for(const t in this.style)this.style.hasOwnProperty(t)&&(e.style[t]=this.style[t]);return e}toMarkup(){let e='<img src="'+l.escape(this.src)+'" alt="'+l.escape(this.alt)+'"',t="";for(const e in this.style)this.style.hasOwnProperty(e)&&(t+=l.hyphenate(e)+":"+this.style[e]+";");return t&&(e+=' style="'+l.escape(t)+'"'),e+="'/>",e}}const Z={"\xee":"\u0131\u0302","\xef":"\u0131\u0308","\xed":"\u0131\u0301","\xec":"\u0131\u0300"};class K{constructor(e,t,r,n,o,s,i,a){this.text=void 0,this.height=void 0,this.depth=void 0,this.italic=void 0,this.skew=void 0,this.width=void 0,this.maxFontSize=void 0,this.classes=void 0,this.style=void 0,this.text=e,this.height=t||0,this.depth=r||0,this.italic=n||0,this.skew=o||0,this.width=s||0,this.classes=i||[],this.style=a||{},this.maxFontSize=0;const l=function(e){for(let t=0;t<v.length;t++){const r=v[t];for(let t=0;t<r.blocks.length;t++){const n=r.blocks[t];if(e>=n[0]&&e<=n[1])return r.name}}return null}(this.text.charCodeAt(0));l&&this.classes.push(l+"_fallback"),/[\xee\xef\xed\xec]/.test(this.text)&&(this.text=Z[this.text])}hasClass(e){return l.contains(this.classes,e)}toNode(){const e=document.createTextNode(this.text);let t=null;this.italic>0&&(t=document.createElement("span"),t.style.marginRight=F(this.italic)),this.classes.length>0&&(t=t||document.createElement("span"),t.className=G(this.classes));for(const e in this.style)this.style.hasOwnProperty(e)&&(t=t||document.createElement("span"),t.style[e]=this.style[e]);return t?(t.appendChild(e),t):e}toMarkup(){let e=!1,t="<span";this.classes.length&&(e=!0,t+=' class="',t+=l.escape(G(this.classes)),t+='"');let r="";this.italic>0&&(r+="margin-right:"+this.italic+"em;");for(const e in this.style)this.style.hasOwnProperty(e)&&(r+=l.hyphenate(e)+":"+this.style[e]+";");r&&(e=!0,t+=' style="'+l.escape(r)+'"');const n=l.escape(this.text);return e?(t+=">",t+=n,t+="</span>",t):n}}class J{constructor(e,t){this.children=void 0,this.attributes=void 0,this.children=e||[],this.attributes=t||{}}toNode(){const e=document.createElementNS("http://www.w3.org/2000/svg","svg");for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&e.setAttribute(t,this.attributes[t]);for(let t=0;t<this.children.length;t++)e.appendChild(this.children[t].toNode());return e}toMarkup(){let e='<svg xmlns="http://www.w3.org/2000/svg"';for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&(e+=" "+t+'="'+l.escape(this.attributes[t])+'"');e+=">";for(let t=0;t<this.children.length;t++)e+=this.children[t].toMarkup();return e+="</svg>",e}}class Q{constructor(e,t){this.pathName=void 0,this.alternate=void 0,this.pathName=e,this.alternate=t}toNode(){const e=document.createElementNS("http://www.w3.org/2000/svg","path");return this.alternate?e.setAttribute("d",this.alternate):e.setAttribute("d",z[this.pathName]),e}toMarkup(){return this.alternate?'<path d="'+l.escape(this.alternate)+'"/>':'<path d="'+l.escape(z[this.pathName])+'"/>'}}class ee{constructor(e){this.attributes=void 0,this.attributes=e||{}}toNode(){const e=document.createElementNS("http://www.w3.org/2000/svg","line");for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&e.setAttribute(t,this.attributes[t]);return e}toMarkup(){let e="<line";for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&(e+=" "+t+'="'+l.escape(this.attributes[t])+'"');return e+="/>",e}}function te(e){if(e instanceof K)return e;throw new Error("Expected symbolNode but got "+String(e)+".")}const re={bin:1,close:1,inner:1,open:1,punct:1,rel:1},ne={"accent-token":1,mathord:1,"op-token":1,spacing:1,textord:1},oe={math:{},text:{}};var se=oe;function ie(e,t,r,n,o,s){oe[e][o]={font:t,group:r,replace:n},s&&n&&(oe[e][n]=oe[e][o])}const ae="math",le="text",he="main",ce="ams",me="accent-token",pe="bin",ue="close",de="inner",ge="mathord",fe="op-token",be="open",ye="punct",xe="rel",we="spacing",ve="textord";ie(ae,he,xe,"\u2261","\\equiv",!0),ie(ae,he,xe,"\u227a","\\prec",!0),ie(ae,he,xe,"\u227b","\\succ",!0),ie(ae,he,xe,"\u223c","\\sim",!0),ie(ae,he,xe,"\u22a5","\\perp"),ie(ae,he,xe,"\u2aaf","\\preceq",!0),ie(ae,he,xe,"\u2ab0","\\succeq",!0),ie(ae,he,xe,"\u2243","\\simeq",!0),ie(ae,he,xe,"\u2223","\\mid",!0),ie(ae,he,xe,"\u226a","\\ll",!0),ie(ae,he,xe,"\u226b","\\gg",!0),ie(ae,he,xe,"\u224d","\\asymp",!0),ie(ae,he,xe,"\u2225","\\parallel"),ie(ae,he,xe,"\u22c8","\\bowtie",!0),ie(ae,he,xe,"\u2323","\\smile",!0),ie(ae,he,xe,"\u2291","\\sqsubseteq",!0),ie(ae,he,xe,"\u2292","\\sqsupseteq",!0),ie(ae,he,xe,"\u2250","\\doteq",!0),ie(ae,he,xe,"\u2322","\\frown",!0),ie(ae,he,xe,"\u220b","\\ni",!0),ie(ae,he,xe,"\u221d","\\propto",!0),ie(ae,he,xe,"\u22a2","\\vdash",!0),ie(ae,he,xe,"\u22a3","\\dashv",!0),ie(ae,he,xe,"\u220b","\\owns"),ie(ae,he,ye,".","\\ldotp"),ie(ae,he,ye,"\u22c5","\\cdotp"),ie(ae,he,ve,"#","\\#"),ie(le,he,ve,"#","\\#"),ie(ae,he,ve,"&","\\&"),ie(le,he,ve,"&","\\&"),ie(ae,he,ve,"\u2135","\\aleph",!0),ie(ae,he,ve,"\u2200","\\forall",!0),ie(ae,he,ve,"\u210f","\\hbar",!0),ie(ae,he,ve,"\u2203","\\exists",!0),ie(ae,he,ve,"\u2207","\\nabla",!0),ie(ae,he,ve,"\u266d","\\flat",!0),ie(ae,he,ve,"\u2113","\\ell",!0),ie(ae,he,ve,"\u266e","\\natural",!0),ie(ae,he,ve,"\u2663","\\clubsuit",!0),ie(ae,he,ve,"\u2118","\\wp",!0),ie(ae,he,ve,"\u266f","\\sharp",!0),ie(ae,he,ve,"\u2662","\\diamondsuit",!0),ie(ae,he,ve,"\u211c","\\Re",!0),ie(ae,he,ve,"\u2661","\\heartsuit",!0),ie(ae,he,ve,"\u2111","\\Im",!0),ie(ae,he,ve,"\u2660","\\spadesuit",!0),ie(ae,he,ve,"\xa7","\\S",!0),ie(le,he,ve,"\xa7","\\S"),ie(ae,he,ve,"\xb6","\\P",!0),ie(le,he,ve,"\xb6","\\P"),ie(ae,he,ve,"\u2020","\\dag"),ie(le,he,ve,"\u2020","\\dag"),ie(le,he,ve,"\u2020","\\textdagger"),ie(ae,he,ve,"\u2021","\\ddag"),ie(le,he,ve,"\u2021","\\ddag"),ie(le,he,ve,"\u2021","\\textdaggerdbl"),ie(ae,he,ue,"\u23b1","\\rmoustache",!0),ie(ae,he,be,"\u23b0","\\lmoustache",!0),ie(ae,he,ue,"\u27ef","\\rgroup",!0),ie(ae,he,be,"\u27ee","\\lgroup",!0),ie(ae,he,pe,"\u2213","\\mp",!0),ie(ae,he,pe,"\u2296","\\ominus",!0),ie(ae,he,pe,"\u228e","\\uplus",!0),ie(ae,he,pe,"\u2293","\\sqcap",!0),ie(ae,he,pe,"\u2217","\\ast"),ie(ae,he,pe,"\u2294","\\sqcup",!0),ie(ae,he,pe,"\u25ef","\\bigcirc",!0),ie(ae,he,pe,"\u2219","\\bullet",!0),ie(ae,he,pe,"\u2021","\\ddagger"),ie(ae,he,pe,"\u2240","\\wr",!0),ie(ae,he,pe,"\u2a3f","\\amalg"),ie(ae,he,pe,"&","\\And"),ie(ae,he,xe,"\u27f5","\\longleftarrow",!0),ie(ae,he,xe,"\u21d0","\\Leftarrow",!0),ie(ae,he,xe,"\u27f8","\\Longleftarrow",!0),ie(ae,he,xe,"\u27f6","\\longrightarrow",!0),ie(ae,he,xe,"\u21d2","\\Rightarrow",!0),ie(ae,he,xe,"\u27f9","\\Longrightarrow",!0),ie(ae,he,xe,"\u2194","\\leftrightarrow",!0),ie(ae,he,xe,"\u27f7","\\longleftrightarrow",!0),ie(ae,he,xe,"\u21d4","\\Leftrightarrow",!0),ie(ae,he,xe,"\u27fa","\\Longleftrightarrow",!0),ie(ae,he,xe,"\u21a6","\\mapsto",!0),ie(ae,he,xe,"\u27fc","\\longmapsto",!0),ie(ae,he,xe,"\u2197","\\nearrow",!0),ie(ae,he,xe,"\u21a9","\\hookleftarrow",!0),ie(ae,he,xe,"\u21aa","\\hookrightarrow",!0),ie(ae,he,xe,"\u2198","\\searrow",!0),ie(ae,he,xe,"\u21bc","\\leftharpoonup",!0),ie(ae,he,xe,"\u21c0","\\rightharpoonup",!0),ie(ae,he,xe,"\u2199","\\swarrow",!0),ie(ae,he,xe,"\u21bd","\\leftharpoondown",!0),ie(ae,he,xe,"\u21c1","\\rightharpoondown",!0),ie(ae,he,xe,"\u2196","\\nwarrow",!0),ie(ae,he,xe,"\u21cc","\\rightleftharpoons",!0),ie(ae,ce,xe,"\u226e","\\nless",!0),ie(ae,ce,xe,"\ue010","\\@nleqslant"),ie(ae,ce,xe,"\ue011","\\@nleqq"),ie(ae,ce,xe,"\u2a87","\\lneq",!0),ie(ae,ce,xe,"\u2268","\\lneqq",!0),ie(ae,ce,xe,"\ue00c","\\@lvertneqq"),ie(ae,ce,xe,"\u22e6","\\lnsim",!0),ie(ae,ce,xe,"\u2a89","\\lnapprox",!0),ie(ae,ce,xe,"\u2280","\\nprec",!0),ie(ae,ce,xe,"\u22e0","\\npreceq",!0),ie(ae,ce,xe,"\u22e8","\\precnsim",!0),ie(ae,ce,xe,"\u2ab9","\\precnapprox",!0),ie(ae,ce,xe,"\u2241","\\nsim",!0),ie(ae,ce,xe,"\ue006","\\@nshortmid"),ie(ae,ce,xe,"\u2224","\\nmid",!0),ie(ae,ce,xe,"\u22ac","\\nvdash",!0),ie(ae,ce,xe,"\u22ad","\\nvDash",!0),ie(ae,ce,xe,"\u22ea","\\ntriangleleft"),ie(ae,ce,xe,"\u22ec","\\ntrianglelefteq",!0),ie(ae,ce,xe,"\u228a","\\subsetneq",!0),ie(ae,ce,xe,"\ue01a","\\@varsubsetneq"),ie(ae,ce,xe,"\u2acb","\\subsetneqq",!0),ie(ae,ce,xe,"\ue017","\\@varsubsetneqq"),ie(ae,ce,xe,"\u226f","\\ngtr",!0),ie(ae,ce,xe,"\ue00f","\\@ngeqslant"),ie(ae,ce,xe,"\ue00e","\\@ngeqq"),ie(ae,ce,xe,"\u2a88","\\gneq",!0),ie(ae,ce,xe,"\u2269","\\gneqq",!0),ie(ae,ce,xe,"\ue00d","\\@gvertneqq"),ie(ae,ce,xe,"\u22e7","\\gnsim",!0),ie(ae,ce,xe,"\u2a8a","\\gnapprox",!0),ie(ae,ce,xe,"\u2281","\\nsucc",!0),ie(ae,ce,xe,"\u22e1","\\nsucceq",!0),ie(ae,ce,xe,"\u22e9","\\succnsim",!0),ie(ae,ce,xe,"\u2aba","\\succnapprox",!0),ie(ae,ce,xe,"\u2246","\\ncong",!0),ie(ae,ce,xe,"\ue007","\\@nshortparallel"),ie(ae,ce,xe,"\u2226","\\nparallel",!0),ie(ae,ce,xe,"\u22af","\\nVDash",!0),ie(ae,ce,xe,"\u22eb","\\ntriangleright"),ie(ae,ce,xe,"\u22ed","\\ntrianglerighteq",!0),ie(ae,ce,xe,"\ue018","\\@nsupseteqq"),ie(ae,ce,xe,"\u228b","\\supsetneq",!0),ie(ae,ce,xe,"\ue01b","\\@varsupsetneq"),ie(ae,ce,xe,"\u2acc","\\supsetneqq",!0),ie(ae,ce,xe,"\ue019","\\@varsupsetneqq"),ie(ae,ce,xe,"\u22ae","\\nVdash",!0),ie(ae,ce,xe,"\u2ab5","\\precneqq",!0),ie(ae,ce,xe,"\u2ab6","\\succneqq",!0),ie(ae,ce,xe,"\ue016","\\@nsubseteqq"),ie(ae,ce,pe,"\u22b4","\\unlhd"),ie(ae,ce,pe,"\u22b5","\\unrhd"),ie(ae,ce,xe,"\u219a","\\nleftarrow",!0),ie(ae,ce,xe,"\u219b","\\nrightarrow",!0),ie(ae,ce,xe,"\u21cd","\\nLeftarrow",!0),ie(ae,ce,xe,"\u21cf","\\nRightarrow",!0),ie(ae,ce,xe,"\u21ae","\\nleftrightarrow",!0),ie(ae,ce,xe,"\u21ce","\\nLeftrightarrow",!0),ie(ae,ce,xe,"\u25b3","\\vartriangle"),ie(ae,ce,ve,"\u210f","\\hslash"),ie(ae,ce,ve,"\u25bd","\\triangledown"),ie(ae,ce,ve,"\u25ca","\\lozenge"),ie(ae,ce,ve,"\u24c8","\\circledS"),ie(ae,ce,ve,"\xae","\\circledR"),ie(le,ce,ve,"\xae","\\circledR"),ie(ae,ce,ve,"\u2221","\\measuredangle",!0),ie(ae,ce,ve,"\u2204","\\nexists"),ie(ae,ce,ve,"\u2127","\\mho"),ie(ae,ce,ve,"\u2132","\\Finv",!0),ie(ae,ce,ve,"\u2141","\\Game",!0),ie(ae,ce,ve,"\u2035","\\backprime"),ie(ae,ce,ve,"\u25b2","\\blacktriangle"),ie(ae,ce,ve,"\u25bc","\\blacktriangledown"),ie(ae,ce,ve,"\u25a0","\\blacksquare"),ie(ae,ce,ve,"\u29eb","\\blacklozenge"),ie(ae,ce,ve,"\u2605","\\bigstar"),ie(ae,ce,ve,"\u2222","\\sphericalangle",!0),ie(ae,ce,ve,"\u2201","\\complement",!0),ie(ae,ce,ve,"\xf0","\\eth",!0),ie(le,he,ve,"\xf0","\xf0"),ie(ae,ce,ve,"\u2571","\\diagup"),ie(ae,ce,ve,"\u2572","\\diagdown"),ie(ae,ce,ve,"\u25a1","\\square"),ie(ae,ce,ve,"\u25a1","\\Box"),ie(ae,ce,ve,"\u25ca","\\Diamond"),ie(ae,ce,ve,"\xa5","\\yen",!0),ie(le,ce,ve,"\xa5","\\yen",!0),ie(ae,ce,ve,"\u2713","\\checkmark",!0),ie(le,ce,ve,"\u2713","\\checkmark"),ie(ae,ce,ve,"\u2136","\\beth",!0),ie(ae,ce,ve,"\u2138","\\daleth",!0),ie(ae,ce,ve,"\u2137","\\gimel",!0),ie(ae,ce,ve,"\u03dd","\\digamma",!0),ie(ae,ce,ve,"\u03f0","\\varkappa"),ie(ae,ce,be,"\u250c","\\@ulcorner",!0),ie(ae,ce,ue,"\u2510","\\@urcorner",!0),ie(ae,ce,be,"\u2514","\\@llcorner",!0),ie(ae,ce,ue,"\u2518","\\@lrcorner",!0),ie(ae,ce,xe,"\u2266","\\leqq",!0),ie(ae,ce,xe,"\u2a7d","\\leqslant",!0),ie(ae,ce,xe,"\u2a95","\\eqslantless",!0),ie(ae,ce,xe,"\u2272","\\lesssim",!0),ie(ae,ce,xe,"\u2a85","\\lessapprox",!0),ie(ae,ce,xe,"\u224a","\\approxeq",!0),ie(ae,ce,pe,"\u22d6","\\lessdot"),ie(ae,ce,xe,"\u22d8","\\lll",!0),ie(ae,ce,xe,"\u2276","\\lessgtr",!0),ie(ae,ce,xe,"\u22da","\\lesseqgtr",!0),ie(ae,ce,xe,"\u2a8b","\\lesseqqgtr",!0),ie(ae,ce,xe,"\u2251","\\doteqdot"),ie(ae,ce,xe,"\u2253","\\risingdotseq",!0),ie(ae,ce,xe,"\u2252","\\fallingdotseq",!0),ie(ae,ce,xe,"\u223d","\\backsim",!0),ie(ae,ce,xe,"\u22cd","\\backsimeq",!0),ie(ae,ce,xe,"\u2ac5","\\subseteqq",!0),ie(ae,ce,xe,"\u22d0","\\Subset",!0),ie(ae,ce,xe,"\u228f","\\sqsubset",!0),ie(ae,ce,xe,"\u227c","\\preccurlyeq",!0),ie(ae,ce,xe,"\u22de","\\curlyeqprec",!0),ie(ae,ce,xe,"\u227e","\\precsim",!0),ie(ae,ce,xe,"\u2ab7","\\precapprox",!0),ie(ae,ce,xe,"\u22b2","\\vartriangleleft"),ie(ae,ce,xe,"\u22b4","\\trianglelefteq"),ie(ae,ce,xe,"\u22a8","\\vDash",!0),ie(ae,ce,xe,"\u22aa","\\Vvdash",!0),ie(ae,ce,xe,"\u2323","\\smallsmile"),ie(ae,ce,xe,"\u2322","\\smallfrown"),ie(ae,ce,xe,"\u224f","\\bumpeq",!0),ie(ae,ce,xe,"\u224e","\\Bumpeq",!0),ie(ae,ce,xe,"\u2267","\\geqq",!0),ie(ae,ce,xe,"\u2a7e","\\geqslant",!0),ie(ae,ce,xe,"\u2a96","\\eqslantgtr",!0),ie(ae,ce,xe,"\u2273","\\gtrsim",!0),ie(ae,ce,xe,"\u2a86","\\gtrapprox",!0),ie(ae,ce,pe,"\u22d7","\\gtrdot"),ie(ae,ce,xe,"\u22d9","\\ggg",!0),ie(ae,ce,xe,"\u2277","\\gtrless",!0),ie(ae,ce,xe,"\u22db","\\gtreqless",!0),ie(ae,ce,xe,"\u2a8c","\\gtreqqless",!0),ie(ae,ce,xe,"\u2256","\\eqcirc",!0),ie(ae,ce,xe,"\u2257","\\circeq",!0),ie(ae,ce,xe,"\u225c","\\triangleq",!0),ie(ae,ce,xe,"\u223c","\\thicksim"),ie(ae,ce,xe,"\u2248","\\thickapprox"),ie(ae,ce,xe,"\u2ac6","\\supseteqq",!0),ie(ae,ce,xe,"\u22d1","\\Supset",!0),ie(ae,ce,xe,"\u2290","\\sqsupset",!0),ie(ae,ce,xe,"\u227d","\\succcurlyeq",!0),ie(ae,ce,xe,"\u22df","\\curlyeqsucc",!0),ie(ae,ce,xe,"\u227f","\\succsim",!0),ie(ae,ce,xe,"\u2ab8","\\succapprox",!0),ie(ae,ce,xe,"\u22b3","\\vartriangleright"),ie(ae,ce,xe,"\u22b5","\\trianglerighteq"),ie(ae,ce,xe,"\u22a9","\\Vdash",!0),ie(ae,ce,xe,"\u2223","\\shortmid"),ie(ae,ce,xe,"\u2225","\\shortparallel"),ie(ae,ce,xe,"\u226c","\\between",!0),ie(ae,ce,xe,"\u22d4","\\pitchfork",!0),ie(ae,ce,xe,"\u221d","\\varpropto"),ie(ae,ce,xe,"\u25c0","\\blacktriangleleft"),ie(ae,ce,xe,"\u2234","\\therefore",!0),ie(ae,ce,xe,"\u220d","\\backepsilon"),ie(ae,ce,xe,"\u25b6","\\blacktriangleright"),ie(ae,ce,xe,"\u2235","\\because",!0),ie(ae,ce,xe,"\u22d8","\\llless"),ie(ae,ce,xe,"\u22d9","\\gggtr"),ie(ae,ce,pe,"\u22b2","\\lhd"),ie(ae,ce,pe,"\u22b3","\\rhd"),ie(ae,ce,xe,"\u2242","\\eqsim",!0),ie(ae,he,xe,"\u22c8","\\Join"),ie(ae,ce,xe,"\u2251","\\Doteq",!0),ie(ae,ce,pe,"\u2214","\\dotplus",!0),ie(ae,ce,pe,"\u2216","\\smallsetminus"),ie(ae,ce,pe,"\u22d2","\\Cap",!0),ie(ae,ce,pe,"\u22d3","\\Cup",!0),ie(ae,ce,pe,"\u2a5e","\\doublebarwedge",!0),ie(ae,ce,pe,"\u229f","\\boxminus",!0),ie(ae,ce,pe,"\u229e","\\boxplus",!0),ie(ae,ce,pe,"\u22c7","\\divideontimes",!0),ie(ae,ce,pe,"\u22c9","\\ltimes",!0),ie(ae,ce,pe,"\u22ca","\\rtimes",!0),ie(ae,ce,pe,"\u22cb","\\leftthreetimes",!0),ie(ae,ce,pe,"\u22cc","\\rightthreetimes",!0),ie(ae,ce,pe,"\u22cf","\\curlywedge",!0),ie(ae,ce,pe,"\u22ce","\\curlyvee",!0),ie(ae,ce,pe,"\u229d","\\circleddash",!0),ie(ae,ce,pe,"\u229b","\\circledast",!0),ie(ae,ce,pe,"\u22c5","\\centerdot"),ie(ae,ce,pe,"\u22ba","\\intercal",!0),ie(ae,ce,pe,"\u22d2","\\doublecap"),ie(ae,ce,pe,"\u22d3","\\doublecup"),ie(ae,ce,pe,"\u22a0","\\boxtimes",!0),ie(ae,ce,xe,"\u21e2","\\dashrightarrow",!0),ie(ae,ce,xe,"\u21e0","\\dashleftarrow",!0),ie(ae,ce,xe,"\u21c7","\\leftleftarrows",!0),ie(ae,ce,xe,"\u21c6","\\leftrightarrows",!0),ie(ae,ce,xe,"\u21da","\\Lleftarrow",!0),ie(ae,ce,xe,"\u219e","\\twoheadleftarrow",!0),ie(ae,ce,xe,"\u21a2","\\leftarrowtail",!0),ie(ae,ce,xe,"\u21ab","\\looparrowleft",!0),ie(ae,ce,xe,"\u21cb","\\leftrightharpoons",!0),ie(ae,ce,xe,"\u21b6","\\curvearrowleft",!0),ie(ae,ce,xe,"\u21ba","\\circlearrowleft",!0),ie(ae,ce,xe,"\u21b0","\\Lsh",!0),ie(ae,ce,xe,"\u21c8","\\upuparrows",!0),ie(ae,ce,xe,"\u21bf","\\upharpoonleft",!0),ie(ae,ce,xe,"\u21c3","\\downharpoonleft",!0),ie(ae,he,xe,"\u22b6","\\origof",!0),ie(ae,he,xe,"\u22b7","\\imageof",!0),ie(ae,ce,xe,"\u22b8","\\multimap",!0),ie(ae,ce,xe,"\u21ad","\\leftrightsquigarrow",!0),ie(ae,ce,xe,"\u21c9","\\rightrightarrows",!0),ie(ae,ce,xe,"\u21c4","\\rightleftarrows",!0),ie(ae,ce,xe,"\u21a0","\\twoheadrightarrow",!0),ie(ae,ce,xe,"\u21a3","\\rightarrowtail",!0),ie(ae,ce,xe,"\u21ac","\\looparrowright",!0),ie(ae,ce,xe,"\u21b7","\\curvearrowright",!0),ie(ae,ce,xe,"\u21bb","\\circlearrowright",!0),ie(ae,ce,xe,"\u21b1","\\Rsh",!0),ie(ae,ce,xe,"\u21ca","\\downdownarrows",!0),ie(ae,ce,xe,"\u21be","\\upharpoonright",!0),ie(ae,ce,xe,"\u21c2","\\downharpoonright",!0),ie(ae,ce,xe,"\u21dd","\\rightsquigarrow",!0),ie(ae,ce,xe,"\u21dd","\\leadsto"),ie(ae,ce,xe,"\u21db","\\Rrightarrow",!0),ie(ae,ce,xe,"\u21be","\\restriction"),ie(ae,he,ve,"\u2018","`"),ie(ae,he,ve,"$","\\$"),ie(le,he,ve,"$","\\$"),ie(le,he,ve,"$","\\textdollar"),ie(ae,he,ve,"%","\\%"),ie(le,he,ve,"%","\\%"),ie(ae,he,ve,"_","\\_"),ie(le,he,ve,"_","\\_"),ie(le,he,ve,"_","\\textunderscore"),ie(ae,he,ve,"\u2220","\\angle",!0),ie(ae,he,ve,"\u221e","\\infty",!0),ie(ae,he,ve,"\u2032","\\prime"),ie(ae,he,ve,"\u25b3","\\triangle"),ie(ae,he,ve,"\u0393","\\Gamma",!0),ie(ae,he,ve,"\u0394","\\Delta",!0),ie(ae,he,ve,"\u0398","\\Theta",!0),ie(ae,he,ve,"\u039b","\\Lambda",!0),ie(ae,he,ve,"\u039e","\\Xi",!0),ie(ae,he,ve,"\u03a0","\\Pi",!0),ie(ae,he,ve,"\u03a3","\\Sigma",!0),ie(ae,he,ve,"\u03a5","\\Upsilon",!0),ie(ae,he,ve,"\u03a6","\\Phi",!0),ie(ae,he,ve,"\u03a8","\\Psi",!0),ie(ae,he,ve,"\u03a9","\\Omega",!0),ie(ae,he,ve,"A","\u0391"),ie(ae,he,ve,"B","\u0392"),ie(ae,he,ve,"E","\u0395"),ie(ae,he,ve,"Z","\u0396"),ie(ae,he,ve,"H","\u0397"),ie(ae,he,ve,"I","\u0399"),ie(ae,he,ve,"K","\u039a"),ie(ae,he,ve,"M","\u039c"),ie(ae,he,ve,"N","\u039d"),ie(ae,he,ve,"O","\u039f"),ie(ae,he,ve,"P","\u03a1"),ie(ae,he,ve,"T","\u03a4"),ie(ae,he,ve,"X","\u03a7"),ie(ae,he,ve,"\xac","\\neg",!0),ie(ae,he,ve,"\xac","\\lnot"),ie(ae,he,ve,"\u22a4","\\top"),ie(ae,he,ve,"\u22a5","\\bot"),ie(ae,he,ve,"\u2205","\\emptyset"),ie(ae,ce,ve,"\u2205","\\varnothing"),ie(ae,he,ge,"\u03b1","\\alpha",!0),ie(ae,he,ge,"\u03b2","\\beta",!0),ie(ae,he,ge,"\u03b3","\\gamma",!0),ie(ae,he,ge,"\u03b4","\\delta",!0),ie(ae,he,ge,"\u03f5","\\epsilon",!0),ie(ae,he,ge,"\u03b6","\\zeta",!0),ie(ae,he,ge,"\u03b7","\\eta",!0),ie(ae,he,ge,"\u03b8","\\theta",!0),ie(ae,he,ge,"\u03b9","\\iota",!0),ie(ae,he,ge,"\u03ba","\\kappa",!0),ie(ae,he,ge,"\u03bb","\\lambda",!0),ie(ae,he,ge,"\u03bc","\\mu",!0),ie(ae,he,ge,"\u03bd","\\nu",!0),ie(ae,he,ge,"\u03be","\\xi",!0),ie(ae,he,ge,"\u03bf","\\omicron",!0),ie(ae,he,ge,"\u03c0","\\pi",!0),ie(ae,he,ge,"\u03c1","\\rho",!0),ie(ae,he,ge,"\u03c3","\\sigma",!0),ie(ae,he,ge,"\u03c4","\\tau",!0),ie(ae,he,ge,"\u03c5","\\upsilon",!0),ie(ae,he,ge,"\u03d5","\\phi",!0),ie(ae,he,ge,"\u03c7","\\chi",!0),ie(ae,he,ge,"\u03c8","\\psi",!0),ie(ae,he,ge,"\u03c9","\\omega",!0),ie(ae,he,ge,"\u03b5","\\varepsilon",!0),ie(ae,he,ge,"\u03d1","\\vartheta",!0),ie(ae,he,ge,"\u03d6","\\varpi",!0),ie(ae,he,ge,"\u03f1","\\varrho",!0),ie(ae,he,ge,"\u03c2","\\varsigma",!0),ie(ae,he,ge,"\u03c6","\\varphi",!0),ie(ae,he,pe,"\u2217","*",!0),ie(ae,he,pe,"+","+"),ie(ae,he,pe,"\u2212","-",!0),ie(ae,he,pe,"\u22c5","\\cdot",!0),ie(ae,he,pe,"\u2218","\\circ",!0),ie(ae,he,pe,"\xf7","\\div",!0),ie(ae,he,pe,"\xb1","\\pm",!0),ie(ae,he,pe,"\xd7","\\times",!0),ie(ae,he,pe,"\u2229","\\cap",!0),ie(ae,he,pe,"\u222a","\\cup",!0),ie(ae,he,pe,"\u2216","\\setminus",!0),ie(ae,he,pe,"\u2227","\\land"),ie(ae,he,pe,"\u2228","\\lor"),ie(ae,he,pe,"\u2227","\\wedge",!0),ie(ae,he,pe,"\u2228","\\vee",!0),ie(ae,he,ve,"\u221a","\\surd"),ie(ae,he,be,"\u27e8","\\langle",!0),ie(ae,he,be,"\u2223","\\lvert"),ie(ae,he,be,"\u2225","\\lVert"),ie(ae,he,ue,"?","?"),ie(ae,he,ue,"!","!"),ie(ae,he,ue,"\u27e9","\\rangle",!0),ie(ae,he,ue,"\u2223","\\rvert"),ie(ae,he,ue,"\u2225","\\rVert"),ie(ae,he,xe,"=","="),ie(ae,he,xe,":",":"),ie(ae,he,xe,"\u2248","\\approx",!0),ie(ae,he,xe,"\u2245","\\cong",!0),ie(ae,he,xe,"\u2265","\\ge"),ie(ae,he,xe,"\u2265","\\geq",!0),ie(ae,he,xe,"\u2190","\\gets"),ie(ae,he,xe,">","\\gt",!0),ie(ae,he,xe,"\u2208","\\in",!0),ie(ae,he,xe,"\ue020","\\@not"),ie(ae,he,xe,"\u2282","\\subset",!0),ie(ae,he,xe,"\u2283","\\supset",!0),ie(ae,he,xe,"\u2286","\\subseteq",!0),ie(ae,he,xe,"\u2287","\\supseteq",!0),ie(ae,ce,xe,"\u2288","\\nsubseteq",!0),ie(ae,ce,xe,"\u2289","\\nsupseteq",!0),ie(ae,he,xe,"\u22a8","\\models"),ie(ae,he,xe,"\u2190","\\leftarrow",!0),ie(ae,he,xe,"\u2264","\\le"),ie(ae,he,xe,"\u2264","\\leq",!0),ie(ae,he,xe,"<","\\lt",!0),ie(ae,he,xe,"\u2192","\\rightarrow",!0),ie(ae,he,xe,"\u2192","\\to"),ie(ae,ce,xe,"\u2271","\\ngeq",!0),ie(ae,ce,xe,"\u2270","\\nleq",!0),ie(ae,he,we,"\xa0","\\ "),ie(ae,he,we,"\xa0","\\space"),ie(ae,he,we,"\xa0","\\nobreakspace"),ie(le,he,we,"\xa0","\\ "),ie(le,he,we,"\xa0"," "),ie(le,he,we,"\xa0","\\space"),ie(le,he,we,"\xa0","\\nobreakspace"),ie(ae,he,we,null,"\\nobreak"),ie(ae,he,we,null,"\\allowbreak"),ie(ae,he,ye,",",","),ie(ae,he,ye,";",";"),ie(ae,ce,pe,"\u22bc","\\barwedge",!0),ie(ae,ce,pe,"\u22bb","\\veebar",!0),ie(ae,he,pe,"\u2299","\\odot",!0),ie(ae,he,pe,"\u2295","\\oplus",!0),ie(ae,he,pe,"\u2297","\\otimes",!0),ie(ae,he,ve,"\u2202","\\partial",!0),ie(ae,he,pe,"\u2298","\\oslash",!0),ie(ae,ce,pe,"\u229a","\\circledcirc",!0),ie(ae,ce,pe,"\u22a1","\\boxdot",!0),ie(ae,he,pe,"\u25b3","\\bigtriangleup"),ie(ae,he,pe,"\u25bd","\\bigtriangledown"),ie(ae,he,pe,"\u2020","\\dagger"),ie(ae,he,pe,"\u22c4","\\diamond"),ie(ae,he,pe,"\u22c6","\\star"),ie(ae,he,pe,"\u25c3","\\triangleleft"),ie(ae,he,pe,"\u25b9","\\triangleright"),ie(ae,he,be,"{","\\{"),ie(le,he,ve,"{","\\{"),ie(le,he,ve,"{","\\textbraceleft"),ie(ae,he,ue,"}","\\}"),ie(le,he,ve,"}","\\}"),ie(le,he,ve,"}","\\textbraceright"),ie(ae,he,be,"{","\\lbrace"),ie(ae,he,ue,"}","\\rbrace"),ie(ae,he,be,"[","\\lbrack",!0),ie(le,he,ve,"[","\\lbrack",!0),ie(ae,he,ue,"]","\\rbrack",!0),ie(le,he,ve,"]","\\rbrack",!0),ie(ae,he,be,"(","\\lparen",!0),ie(ae,he,ue,")","\\rparen",!0),ie(le,he,ve,"<","\\textless",!0),ie(le,he,ve,">","\\textgreater",!0),ie(ae,he,be,"\u230a","\\lfloor",!0),ie(ae,he,ue,"\u230b","\\rfloor",!0),ie(ae,he,be,"\u2308","\\lceil",!0),ie(ae,he,ue,"\u2309","\\rceil",!0),ie(ae,he,ve,"\\","\\backslash"),ie(ae,he,ve,"\u2223","|"),ie(ae,he,ve,"\u2223","\\vert"),ie(le,he,ve,"|","\\textbar",!0),ie(ae,he,ve,"\u2225","\\|"),ie(ae,he,ve,"\u2225","\\Vert"),ie(le,he,ve,"\u2225","\\textbardbl"),ie(le,he,ve,"~","\\textasciitilde"),ie(le,he,ve,"\\","\\textbackslash"),ie(le,he,ve,"^","\\textasciicircum"),ie(ae,he,xe,"\u2191","\\uparrow",!0),ie(ae,he,xe,"\u21d1","\\Uparrow",!0),ie(ae,he,xe,"\u2193","\\downarrow",!0),ie(ae,he,xe,"\u21d3","\\Downarrow",!0),ie(ae,he,xe,"\u2195","\\updownarrow",!0),ie(ae,he,xe,"\u21d5","\\Updownarrow",!0),ie(ae,he,fe,"\u2210","\\coprod"),ie(ae,he,fe,"\u22c1","\\bigvee"),ie(ae,he,fe,"\u22c0","\\bigwedge"),ie(ae,he,fe,"\u2a04","\\biguplus"),ie(ae,he,fe,"\u22c2","\\bigcap"),ie(ae,he,fe,"\u22c3","\\bigcup"),ie(ae,he,fe,"\u222b","\\int"),ie(ae,he,fe,"\u222b","\\intop"),ie(ae,he,fe,"\u222c","\\iint"),ie(ae,he,fe,"\u222d","\\iiint"),ie(ae,he,fe,"\u220f","\\prod"),ie(ae,he,fe,"\u2211","\\sum"),ie(ae,he,fe,"\u2a02","\\bigotimes"),ie(ae,he,fe,"\u2a01","\\bigoplus"),ie(ae,he,fe,"\u2a00","\\bigodot"),ie(ae,he,fe,"\u222e","\\oint"),ie(ae,he,fe,"\u222f","\\oiint"),ie(ae,he,fe,"\u2230","\\oiiint"),ie(ae,he,fe,"\u2a06","\\bigsqcup"),ie(ae,he,fe,"\u222b","\\smallint"),ie(le,he,de,"\u2026","\\textellipsis"),ie(ae,he,de,"\u2026","\\mathellipsis"),ie(le,he,de,"\u2026","\\ldots",!0),ie(ae,he,de,"\u2026","\\ldots",!0),ie(ae,he,de,"\u22ef","\\@cdots",!0),ie(ae,he,de,"\u22f1","\\ddots",!0),ie(ae,he,ve,"\u22ee","\\varvdots"),ie(le,he,ve,"\u22ee","\\varvdots"),ie(ae,he,me,"\u02ca","\\acute"),ie(ae,he,me,"\u02cb","\\grave"),ie(ae,he,me,"\xa8","\\ddot"),ie(ae,he,me,"~","\\tilde"),ie(ae,he,me,"\u02c9","\\bar"),ie(ae,he,me,"\u02d8","\\breve"),ie(ae,he,me,"\u02c7","\\check"),ie(ae,he,me,"^","\\hat"),ie(ae,he,me,"\u20d7","\\vec"),ie(ae,he,me,"\u02d9","\\dot"),ie(ae,he,me,"\u02da","\\mathring"),ie(ae,he,ge,"\ue131","\\@imath"),ie(ae,he,ge,"\ue237","\\@jmath"),ie(ae,he,ve,"\u0131","\u0131"),ie(ae,he,ve,"\u0237","\u0237"),ie(le,he,ve,"\u0131","\\i",!0),ie(le,he,ve,"\u0237","\\j",!0),ie(le,he,ve,"\xdf","\\ss",!0),ie(le,he,ve,"\xe6","\\ae",!0),ie(le,he,ve,"\u0153","\\oe",!0),ie(le,he,ve,"\xf8","\\o",!0),ie(le,he,ve,"\xc6","\\AE",!0),ie(le,he,ve,"\u0152","\\OE",!0),ie(le,he,ve,"\xd8","\\O",!0),ie(le,he,me,"\u02ca","\\'"),ie(le,he,me,"\u02cb","\\`"),ie(le,he,me,"\u02c6","\\^"),ie(le,he,me,"\u02dc","\\~"),ie(le,he,me,"\u02c9","\\="),ie(le,he,me,"\u02d8","\\u"),ie(le,he,me,"\u02d9","\\."),ie(le,he,me,"\xb8","\\c"),ie(le,he,me,"\u02da","\\r"),ie(le,he,me,"\u02c7","\\v"),ie(le,he,me,"\xa8",'\\"'),ie(le,he,me,"\u02dd","\\H"),ie(le,he,me,"\u25ef","\\textcircled");const ke={"--":!0,"---":!0,"``":!0,"''":!0};ie(le,he,ve,"\u2013","--",!0),ie(le,he,ve,"\u2013","\\textendash"),ie(le,he,ve,"\u2014","---",!0),ie(le,he,ve,"\u2014","\\textemdash"),ie(le,he,ve,"\u2018","`",!0),ie(le,he,ve,"\u2018","\\textquoteleft"),ie(le,he,ve,"\u2019","'",!0),ie(le,he,ve,"\u2019","\\textquoteright"),ie(le,he,ve,"\u201c","``",!0),ie(le,he,ve,"\u201c","\\textquotedblleft"),ie(le,he,ve,"\u201d","''",!0),ie(le,he,ve,"\u201d","\\textquotedblright"),ie(ae,he,ve,"\xb0","\\degree",!0),ie(le,he,ve,"\xb0","\\degree"),ie(le,he,ve,"\xb0","\\textdegree",!0),ie(ae,he,ve,"\xa3","\\pounds"),ie(ae,he,ve,"\xa3","\\mathsterling",!0),ie(le,he,ve,"\xa3","\\pounds"),ie(le,he,ve,"\xa3","\\textsterling",!0),ie(ae,ce,ve,"\u2720","\\maltese"),ie(le,ce,ve,"\u2720","\\maltese");const Se='0123456789/@."';for(let e=0;e<14;e++){const t=Se.charAt(e);ie(ae,he,ve,t,t)}const Me='0123456789!@*()-=+";:?/.,';for(let e=0;e<25;e++){const t=Me.charAt(e);ie(le,he,ve,t,t)}const ze="ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz";for(let e=0;e<52;e++){const t=ze.charAt(e);ie(ae,he,ge,t,t),ie(le,he,ve,t,t)}ie(ae,ce,ve,"C","\u2102"),ie(le,ce,ve,"C","\u2102"),ie(ae,ce,ve,"H","\u210d"),ie(le,ce,ve,"H","\u210d"),ie(ae,ce,ve,"N","\u2115"),ie(le,ce,ve,"N","\u2115"),ie(ae,ce,ve,"P","\u2119"),ie(le,ce,ve,"P","\u2119"),ie(ae,ce,ve,"Q","\u211a"),ie(le,ce,ve,"Q","\u211a"),ie(ae,ce,ve,"R","\u211d"),ie(le,ce,ve,"R","\u211d"),ie(ae,ce,ve,"Z","\u2124"),ie(le,ce,ve,"Z","\u2124"),ie(ae,he,ge,"h","\u210e"),ie(le,he,ge,"h","\u210e");let Ae="";for(let e=0;e<52;e++){const t=ze.charAt(e);Ae=String.fromCharCode(55349,56320+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56372+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56424+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56580+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56684+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56736+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56788+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56840+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56944+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),e<26&&(Ae=String.fromCharCode(55349,56632+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,56476+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae))}Ae=String.fromCharCode(55349,56668),ie(ae,he,ge,"k",Ae),ie(le,he,ve,"k",Ae);for(let e=0;e<10;e++){const t=e.toString();Ae=String.fromCharCode(55349,57294+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,57314+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,57324+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae),Ae=String.fromCharCode(55349,57334+e),ie(ae,he,ge,t,Ae),ie(le,he,ve,t,Ae)}const Te="\xd0\xde\xfe";for(let e=0;e<3;e++){const t=Te.charAt(e);ie(ae,he,ge,t,t),ie(le,he,ve,t,t)}const Be=[["mathbf","textbf","Main-Bold"],["mathbf","textbf","Main-Bold"],["mathnormal","textit","Math-Italic"],["mathnormal","textit","Math-Italic"],["boldsymbol","boldsymbol","Main-BoldItalic"],["boldsymbol","boldsymbol","Main-BoldItalic"],["mathscr","textscr","Script-Regular"],["","",""],["","",""],["","",""],["mathfrak","textfrak","Fraktur-Regular"],["mathfrak","textfrak","Fraktur-Regular"],["mathbb","textbb","AMS-Regular"],["mathbb","textbb","AMS-Regular"],["mathboldfrak","textboldfrak","Fraktur-Regular"],["mathboldfrak","textboldfrak","Fraktur-Regular"],["mathsf","textsf","SansSerif-Regular"],["mathsf","textsf","SansSerif-Regular"],["mathboldsf","textboldsf","SansSerif-Bold"],["mathboldsf","textboldsf","SansSerif-Bold"],["mathitsf","textitsf","SansSerif-Italic"],["mathitsf","textitsf","SansSerif-Italic"],["","",""],["","",""],["mathtt","texttt","Typewriter-Regular"],["mathtt","texttt","Typewriter-Regular"]],Ce=[["mathbf","textbf","Main-Bold"],["","",""],["mathsf","textsf","SansSerif-Regular"],["mathboldsf","textboldsf","SansSerif-Bold"],["mathtt","texttt","Typewriter-Regular"]],Ne=function(e,t,r){return se[r][e]&&se[r][e].replace&&(e=se[r][e].replace),{value:e,metrics:N(e,t,r)}},qe=function(e,t,r,n,o){const s=Ne(e,t,r),i=s.metrics;let a;if(e=s.value,i){let t=i.italic;("text"===r||n&&"mathit"===n.font)&&(t=0),a=new K(e,i.height,i.depth,t,i.skew,i.width,o)}else"undefined"!=typeof console&&console.warn("No character metrics for '"+e+"' in style '"+t+"' and mode '"+r+"'"),a=new K(e,0,0,0,0,0,o);if(n){a.maxFontSize=n.sizeMultiplier,n.style.isTight()&&a.classes.push("mtight");const e=n.getColor();e&&(a.style.color=e)}return a},Ie=(e,t)=>{if(G(e.classes)!==G(t.classes)||e.skew!==t.skew||e.maxFontSize!==t.maxFontSize)return!1;if(1===e.classes.length){const t=e.classes[0];if("mbin"===t||"mord"===t)return!1}for(const r in e.style)if(e.style.hasOwnProperty(r)&&e.style[r]!==t.style[r])return!1;for(const r in t.style)if(t.style.hasOwnProperty(r)&&e.style[r]!==t.style[r])return!1;return!0},Re=function(e){let t=0,r=0,n=0;for(let o=0;o<e.children.length;o++){const s=e.children[o];s.height>t&&(t=s.height),s.depth>r&&(r=s.depth),s.maxFontSize>n&&(n=s.maxFontSize)}e.height=t,e.depth=r,e.maxFontSize=n},He=function(e,t,r,n){const o=new _(e,t,r,n);return Re(o),o},Oe=(e,t,r,n)=>new _(e,t,r,n),Ee=function(e){const t=new A(e);return Re(t),t},Le=function(e,t,r){let n,o="";switch(e){case"amsrm":o="AMS";break;case"textrm":o="Main";break;case"textsf":o="SansSerif";break;case"texttt":o="Typewriter";break;default:o=e}return n="textbf"===t&&"textit"===r?"BoldItalic":"textbf"===t?"Bold":"textit"===t?"Italic":"Regular",o+"-"+n},De={mathbf:{variant:"bold",fontName:"Main-Bold"},mathrm:{variant:"normal",fontName:"Main-Regular"},textit:{variant:"italic",fontName:"Main-Italic"},mathit:{variant:"italic",fontName:"Main-Italic"},mathnormal:{variant:"italic",fontName:"Math-Italic"},mathsfit:{variant:"sans-serif-italic",fontName:"SansSerif-Italic"},mathbb:{variant:"double-struck",fontName:"AMS-Regular"},mathcal:{variant:"script",fontName:"Caligraphic-Regular"},mathfrak:{variant:"fraktur",fontName:"Fraktur-Regular"},mathscr:{variant:"script",fontName:"Script-Regular"},mathsf:{variant:"sans-serif",fontName:"SansSerif-Regular"},mathtt:{variant:"monospace",fontName:"Typewriter-Regular"}},Ve={vec:["vec",.471,.714],oiintSize1:["oiintSize1",.957,.499],oiintSize2:["oiintSize2",1.472,.659],oiiintSize1:["oiiintSize1",1.304,.499],oiiintSize2:["oiiintSize2",1.98,.659]};var Pe={fontMap:De,makeSymbol:qe,mathsym:function(e,t,r,n){return void 0===n&&(n=[]),"boldsymbol"===r.font&&Ne(e,"Main-Bold",t).metrics?qe(e,"Main-Bold",t,r,n.concat(["mathbf"])):"\\"===e||"main"===se[t][e].font?qe(e,"Main-Regular",t,r,n):qe(e,"AMS-Regular",t,r,n.concat(["amsrm"]))},makeSpan:He,makeSvgSpan:Oe,makeLineSpan:function(e,t,r){const n=He([e],[],t);return n.height=Math.max(r||t.fontMetrics().defaultRuleThickness,t.minRuleThickness),n.style.borderBottomWidth=F(n.height),n.maxFontSize=1,n},makeAnchor:function(e,t,r,n){const o=new j(e,t,r,n);return Re(o),o},makeFragment:Ee,wrapFragment:function(e,t){return e instanceof A?He([],[e],t):e},makeVList:function(e,t){const{children:r,depth:n}=function(e){if("individualShift"===e.positionType){const t=e.children,r=[t[0]],n=-t[0].shift-t[0].elem.depth;let o=n;for(let e=1;e<t.length;e++){const n=-t[e].shift-o-t[e].elem.depth,s=n-(t[e-1].elem.height+t[e-1].elem.depth);o+=n,r.push({type:"kern",size:s}),r.push(t[e])}return{children:r,depth:n}}let t;if("top"===e.positionType){let r=e.positionData;for(let t=0;t<e.children.length;t++){const n=e.children[t];r-="kern"===n.type?n.size:n.elem.height+n.elem.depth}t=r}else if("bottom"===e.positionType)t=-e.positionData;else{const r=e.children[0];if("elem"!==r.type)throw new Error('First child must have type "elem".');if("shift"===e.positionType)t=-r.elem.depth-e.positionData;else{if("firstBaseline"!==e.positionType)throw new Error("Invalid positionType "+e.positionType+".");t=-r.elem.depth}}return{children:e.children,depth:t}}(e);let o=0;for(let e=0;e<r.length;e++){const t=r[e];if("elem"===t.type){const e=t.elem;o=Math.max(o,e.maxFontSize,e.height)}}o+=2;const s=He(["pstrut"],[]);s.style.height=F(o);const i=[];let a=n,l=n,h=n;for(let e=0;e<r.length;e++){const t=r[e];if("kern"===t.type)h+=t.size;else{const e=t.elem,r=t.wrapperClasses||[],n=t.wrapperStyle||{},a=He(r,[s,e],void 0,n);a.style.top=F(-o-h-e.depth),t.marginLeft&&(a.style.marginLeft=t.marginLeft),t.marginRight&&(a.style.marginRight=t.marginRight),i.push(a),h+=e.height+e.depth}a=Math.min(a,h),l=Math.max(l,h)}const c=He(["vlist"],i);let m;if(c.style.height=F(l),a<0){const e=He([],[]),t=He(["vlist"],[e]);t.style.height=F(-a);const r=He(["vlist-s"],[new K("\u200b")]);m=[He(["vlist-r"],[c,r]),He(["vlist-r"],[t])]}else m=[He(["vlist-r"],[c])];const p=He(["vlist-t"],m);return 2===m.length&&p.classes.push("vlist-t2"),p.height=l,p.depth=-a,p},makeOrd:function(e,t,r){const o=e.mode,s=e.text,i=["mord"],a="math"===o||"text"===o&&t.font,l=a?t.font:t.fontFamily;let h="",c="";if(55349===s.charCodeAt(0)&&([h,c]=function(e,t){const r=1024*(e.charCodeAt(0)-55296)+(e.charCodeAt(1)-56320)+65536,o="math"===t?0:1;if(119808<=r&&r<120484){const e=Math.floor((r-119808)/26);return[Be[e][2],Be[e][o]]}if(120782<=r&&r<=120831){const e=Math.floor((r-120782)/10);return[Ce[e][2],Ce[e][o]]}if(120485===r||120486===r)return[Be[0][2],Be[0][o]];if(120486<r&&r<120782)return["",""];throw new n("Unsupported character: "+e)}(s,o)),h.length>0)return qe(s,h,o,t,i.concat(c));if(l){let e,n;if("boldsymbol"===l){const t=function(e,t,r,n,o){return"textord"!==o&&Ne(e,"Math-BoldItalic",t).metrics?{fontName:"Math-BoldItalic",fontClass:"boldsymbol"}:{fontName:"Main-Bold",fontClass:"mathbf"}}(s,o,0,0,r);e=t.fontName,n=[t.fontClass]}else a?(e=De[l].fontName,n=[l]):(e=Le(l,t.fontWeight,t.fontShape),n=[l,t.fontWeight,t.fontShape]);if(Ne(s,e,o).metrics)return qe(s,e,o,t,i.concat(n));if(ke.hasOwnProperty(s)&&"Typewriter"===e.slice(0,10)){const r=[];for(let a=0;a<s.length;a++)r.push(qe(s[a],e,o,t,i.concat(n)));return Ee(r)}}if("mathord"===r)return qe(s,"Math-Italic",o,t,i.concat(["mathnormal"]));if("textord"===r){const e=se[o][s]&&se[o][s].font;if("ams"===e){const e=Le("amsrm",t.fontWeight,t.fontShape);return qe(s,e,o,t,i.concat("amsrm",t.fontWeight,t.fontShape))}if("main"!==e&&e){const r=Le(e,t.fontWeight,t.fontShape);return qe(s,r,o,t,i.concat(r,t.fontWeight,t.fontShape))}{const e=Le("textrm",t.fontWeight,t.fontShape);return qe(s,e,o,t,i.concat(t.fontWeight,t.fontShape))}}throw new Error("unexpected type: "+r+" in makeOrd")},makeGlue:(e,t)=>{const r=He(["mspace"],[],t),n=P(e,t);return r.style.marginRight=F(n),r},staticSvg:function(e,t){const[r,n,o]=Ve[e],s=new Q(r),i=new J([s],{width:F(n),height:F(o),style:"width:"+F(n),viewBox:"0 0 "+1e3*n+" "+1e3*o,preserveAspectRatio:"xMinYMin"}),a=Oe(["overlay"],[i],t);return a.height=o,a.style.height=F(o),a.style.width=F(n),a},svgData:Ve,tryCombineChars:e=>{for(let t=0;t<e.length-1;t++){const r=e[t],n=e[t+1];r instanceof K&&n instanceof K&&Ie(r,n)&&(r.text+=n.text,r.height=Math.max(r.height,n.height),r.depth=Math.max(r.depth,n.depth),r.italic=n.italic,e.splice(t+1,1),t--)}return e}};const Fe={number:3,unit:"mu"},Ge={number:4,unit:"mu"},Ue={number:5,unit:"mu"},Ye={mord:{mop:Fe,mbin:Ge,mrel:Ue,minner:Fe},mop:{mord:Fe,mop:Fe,mrel:Ue,minner:Fe},mbin:{mord:Ge,mop:Ge,mopen:Ge,minner:Ge},mrel:{mord:Ue,mop:Ue,mopen:Ue,minner:Ue},mopen:{},mclose:{mop:Fe,mbin:Ge,mrel:Ue,minner:Fe},mpunct:{mord:Fe,mop:Fe,mrel:Ue,mopen:Fe,mclose:Fe,mpunct:Fe,minner:Fe},minner:{mord:Fe,mop:Fe,mbin:Ge,mrel:Ue,mopen:Fe,mpunct:Fe,minner:Fe}},Xe={mord:{mop:Fe},mop:{mord:Fe,mop:Fe},mbin:{},mrel:{},mopen:{},mclose:{mop:Fe},mpunct:{},minner:{mop:Fe}},We={},_e={},je={};function $e(e){let{type:t,names:r,props:n,handler:o,htmlBuilder:s,mathmlBuilder:i}=e;const a={type:t,numArgs:n.numArgs,argTypes:n.argTypes,allowedInArgument:!!n.allowedInArgument,allowedInText:!!n.allowedInText,allowedInMath:void 0===n.allowedInMath||n.allowedInMath,numOptionalArgs:n.numOptionalArgs||0,infix:!!n.infix,primitive:!!n.primitive,handler:o};for(let e=0;e<r.length;++e)We[r[e]]=a;t&&(s&&(_e[t]=s),i&&(je[t]=i))}function Ze(e){let{type:t,htmlBuilder:r,mathmlBuilder:n}=e;$e({type:t,names:[],props:{numArgs:0},handler(){throw new Error("Should never be called.")},htmlBuilder:r,mathmlBuilder:n})}const Ke=function(e){return"ordgroup"===e.type&&1===e.body.length?e.body[0]:e},Je=function(e){return"ordgroup"===e.type?e.body:[e]},Qe=Pe.makeSpan,et=["leftmost","mbin","mopen","mrel","mop","mpunct"],tt=["rightmost","mrel","mclose","mpunct"],rt={display:w.DISPLAY,text:w.TEXT,script:w.SCRIPT,scriptscript:w.SCRIPTSCRIPT},nt={mord:"mord",mop:"mop",mbin:"mbin",mrel:"mrel",mopen:"mopen",mclose:"mclose",mpunct:"mpunct",minner:"minner"},ot=function(e,t,r,n){void 0===n&&(n=[null,null]);const o=[];for(let r=0;r<e.length;r++){const n=ct(e[r],t);if(n instanceof A){const e=n.children;o.push(...e)}else o.push(n)}if(Pe.tryCombineChars(o),!r)return o;let s=t;if(1===e.length){const r=e[0];"sizing"===r.type?s=t.havingSize(r.size):"styling"===r.type&&(s=t.havingStyle(rt[r.style]))}const i=Qe([n[0]||"leftmost"],[],t),a=Qe([n[1]||"rightmost"],[],t),h="root"===r;return st(o,((e,t)=>{const r=t.classes[0],n=e.classes[0];"mbin"===r&&l.contains(tt,n)?t.classes[0]="mord":"mbin"===n&&l.contains(et,r)&&(e.classes[0]="mord")}),{node:i},a,h),st(o,((e,t)=>{const r=lt(t),n=lt(e),o=r&&n?e.hasClass("mtight")?Xe[r][n]:Ye[r][n]:null;if(o)return Pe.makeGlue(o,s)}),{node:i},a,h),o},st=function(e,t,r,n,o){n&&e.push(n);let s=0;for(;s<e.length;s++){const n=e[s],i=it(n);if(i){st(i.children,t,r,null,o);continue}const a=!n.hasClass("mspace");if(a){const o=t(n,r.node);o&&(r.insertAfter?r.insertAfter(o):(e.unshift(o),s++))}a?r.node=n:o&&n.hasClass("newline")&&(r.node=Qe(["leftmost"])),r.insertAfter=(t=>r=>{e.splice(t+1,0,r),s++})(s)}n&&e.pop()},it=function(e){return e instanceof A||e instanceof j||e instanceof _&&e.hasClass("enclosing")?e:null},at=function(e,t){const r=it(e);if(r){const e=r.children;if(e.length){if("right"===t)return at(e[e.length-1],"right");if("left"===t)return at(e[0],"left")}}return e},lt=function(e,t){return e?(t&&(e=at(e,t)),nt[e.classes[0]]||null):null},ht=function(e,t){const r=["nulldelimiter"].concat(e.baseSizingClasses());return Qe(t.concat(r))},ct=function(e,t,r){if(!e)return Qe();if(_e[e.type]){let n=_e[e.type](e,t);if(r&&t.size!==r.size){n=Qe(t.sizingClasses(r),[n],t);const e=t.sizeMultiplier/r.sizeMultiplier;n.height*=e,n.depth*=e}return n}throw new n("Got group of unknown type: '"+e.type+"'")};function mt(e,t){const r=Qe(["base"],e,t),n=Qe(["strut"]);return n.style.height=F(r.height+r.depth),r.depth&&(n.style.verticalAlign=F(-r.depth)),r.children.unshift(n),r}function pt(e,t){let r=null;1===e.length&&"tag"===e[0].type&&(r=e[0].tag,e=e[0].body);const n=ot(e,t,"root");let o;2===n.length&&n[1].hasClass("tag")&&(o=n.pop());const s=[];let i,a=[];for(let e=0;e<n.length;e++)if(a.push(n[e]),n[e].hasClass("mbin")||n[e].hasClass("mrel")||n[e].hasClass("allowbreak")){let r=!1;for(;e<n.length-1&&n[e+1].hasClass("mspace")&&!n[e+1].hasClass("newline");)e++,a.push(n[e]),n[e].hasClass("nobreak")&&(r=!0);r||(s.push(mt(a,t)),a=[])}else n[e].hasClass("newline")&&(a.pop(),a.length>0&&(s.push(mt(a,t)),a=[]),s.push(n[e]));a.length>0&&s.push(mt(a,t)),r?(i=mt(ot(r,t,!0)),i.classes=["tag"],s.push(i)):o&&s.push(o);const l=Qe(["katex-html"],s);if(l.setAttribute("aria-hidden","true"),i){const e=i.children[0];e.style.height=F(l.height+l.depth),l.depth&&(e.style.verticalAlign=F(-l.depth))}return l}function ut(e){return new A(e)}class dt{constructor(e,t,r){this.type=void 0,this.attributes=void 0,this.children=void 0,this.classes=void 0,this.type=e,this.attributes={},this.children=t||[],this.classes=r||[]}setAttribute(e,t){this.attributes[e]=t}getAttribute(e){return this.attributes[e]}toNode(){const e=document.createElementNS("http://www.w3.org/1998/Math/MathML",this.type);for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&e.setAttribute(t,this.attributes[t]);this.classes.length>0&&(e.className=G(this.classes));for(let t=0;t<this.children.length;t++)if(this.children[t]instanceof gt&&this.children[t+1]instanceof gt){let r=this.children[t].toText()+this.children[++t].toText();for(;this.children[t+1]instanceof gt;)r+=this.children[++t].toText();e.appendChild(new gt(r).toNode())}else e.appendChild(this.children[t].toNode());return e}toMarkup(){let e="<"+this.type;for(const t in this.attributes)Object.prototype.hasOwnProperty.call(this.attributes,t)&&(e+=" "+t+'="',e+=l.escape(this.attributes[t]),e+='"');this.classes.length>0&&(e+=' class ="'+l.escape(G(this.classes))+'"'),e+=">";for(let t=0;t<this.children.length;t++)e+=this.children[t].toMarkup();return e+="</"+this.type+">",e}toText(){return this.children.map((e=>e.toText())).join("")}}class gt{constructor(e){this.text=void 0,this.text=e}toNode(){return document.createTextNode(this.text)}toMarkup(){return l.escape(this.toText())}toText(){return this.text}}var ft={MathNode:dt,TextNode:gt,SpaceNode:class{constructor(e){this.width=void 0,this.character=void 0,this.width=e,this.character=e>=.05555&&e<=.05556?"\u200a":e>=.1666&&e<=.1667?"\u2009":e>=.2222&&e<=.2223?"\u2005":e>=.2777&&e<=.2778?"\u2005\u200a":e>=-.05556&&e<=-.05555?"\u200a\u2063":e>=-.1667&&e<=-.1666?"\u2009\u2063":e>=-.2223&&e<=-.2222?"\u205f\u2063":e>=-.2778&&e<=-.2777?"\u2005\u2063":null}toNode(){if(this.character)return document.createTextNode(this.character);{const e=document.createElementNS("http://www.w3.org/1998/Math/MathML","mspace");return e.setAttribute("width",F(this.width)),e}}toMarkup(){return this.character?"<mtext>"+this.character+"</mtext>":'<mspace width="'+F(this.width)+'"/>'}toText(){return this.character?this.character:" "}},newDocumentFragment:ut};const bt=function(e,t,r){return!se[t][e]||!se[t][e].replace||55349===e.charCodeAt(0)||ke.hasOwnProperty(e)&&r&&(r.fontFamily&&"tt"===r.fontFamily.slice(4,6)||r.font&&"tt"===r.font.slice(4,6))||(e=se[t][e].replace),new ft.TextNode(e)},yt=function(e){return 1===e.length?e[0]:new ft.MathNode("mrow",e)},xt=function(e,t){if("texttt"===t.fontFamily)return"monospace";if("textsf"===t.fontFamily)return"textit"===t.fontShape&&"textbf"===t.fontWeight?"sans-serif-bold-italic":"textit"===t.fontShape?"sans-serif-italic":"textbf"===t.fontWeight?"bold-sans-serif":"sans-serif";if("textit"===t.fontShape&&"textbf"===t.fontWeight)return"bold-italic";if("textit"===t.fontShape)return"italic";if("textbf"===t.fontWeight)return"bold";const r=t.font;if(!r||"mathnormal"===r)return null;const n=e.mode;if("mathit"===r)return"italic";if("boldsymbol"===r)return"textord"===e.type?"bold":"bold-italic";if("mathbf"===r)return"bold";if("mathbb"===r)return"double-struck";if("mathsfit"===r)return"sans-serif-italic";if("mathfrak"===r)return"fraktur";if("mathscr"===r||"mathcal"===r)return"script";if("mathsf"===r)return"sans-serif";if("mathtt"===r)return"monospace";let o=e.text;if(l.contains(["\\imath","\\jmath"],o))return null;se[n][o]&&se[n][o].replace&&(o=se[n][o].replace);return N(o,Pe.fontMap[r].fontName,n)?Pe.fontMap[r].variant:null};function wt(e){if(!e)return!1;if("mi"===e.type&&1===e.children.length){const t=e.children[0];return t instanceof gt&&"."===t.text}if("mo"===e.type&&1===e.children.length&&"true"===e.getAttribute("separator")&&"0em"===e.getAttribute("lspace")&&"0em"===e.getAttribute("rspace")){const t=e.children[0];return t instanceof gt&&","===t.text}return!1}const vt=function(e,t,r){if(1===e.length){const n=St(e[0],t);return r&&n instanceof dt&&"mo"===n.type&&(n.setAttribute("lspace","0em"),n.setAttribute("rspace","0em")),[n]}const n=[];let o;for(let r=0;r<e.length;r++){const s=St(e[r],t);if(s instanceof dt&&o instanceof dt){if("mtext"===s.type&&"mtext"===o.type&&s.getAttribute("mathvariant")===o.getAttribute("mathvariant")){o.children.push(...s.children);continue}if("mn"===s.type&&"mn"===o.type){o.children.push(...s.children);continue}if(wt(s)&&"mn"===o.type){o.children.push(...s.children);continue}if("mn"===s.type&&wt(o))s.children=[...o.children,...s.children],n.pop();else if(("msup"===s.type||"msub"===s.type)&&s.children.length>=1&&("mn"===o.type||wt(o))){const e=s.children[0];e instanceof dt&&"mn"===e.type&&(e.children=[...o.children,...e.children],n.pop())}else if("mi"===o.type&&1===o.children.length){const e=o.children[0];if(e instanceof gt&&"\u0338"===e.text&&("mo"===s.type||"mi"===s.type||"mn"===s.type)){const e=s.children[0];e instanceof gt&&e.text.length>0&&(e.text=e.text.slice(0,1)+"\u0338"+e.text.slice(1),n.pop())}}}n.push(s),o=s}return n},kt=function(e,t,r){return yt(vt(e,t,r))},St=function(e,t){if(!e)return new ft.MathNode("mrow");if(je[e.type]){return je[e.type](e,t)}throw new n("Got group of unknown type: '"+e.type+"'")};function Mt(e,t,r,n,o){const s=vt(e,r);let i;i=1===s.length&&s[0]instanceof dt&&l.contains(["mrow","mtable"],s[0].type)?s[0]:new ft.MathNode("mrow",s);const a=new ft.MathNode("annotation",[new ft.TextNode(t)]);a.setAttribute("encoding","application/x-tex");const h=new ft.MathNode("semantics",[i,a]),c=new ft.MathNode("math",[h]);c.setAttribute("xmlns","http://www.w3.org/1998/Math/MathML"),n&&c.setAttribute("display","block");const m=o?"katex":"katex-mathml";return Pe.makeSpan([m],[c])}const zt=function(e){return new E({style:e.displayMode?w.DISPLAY:w.TEXT,maxSize:e.maxSize,minRuleThickness:e.minRuleThickness})},At=function(e,t){if(t.displayMode){const r=["katex-display"];t.leqno&&r.push("leqno"),t.fleqn&&r.push("fleqn"),e=Pe.makeSpan(r,[e])}return e},Tt=function(e,t,r){const n=zt(r);let o;if("mathml"===r.output)return Mt(e,t,n,r.displayMode,!0);if("html"===r.output){const t=pt(e,n);o=Pe.makeSpan(["katex"],[t])}else{const s=Mt(e,t,n,r.displayMode,!1),i=pt(e,n);o=Pe.makeSpan(["katex"],[s,i])}return At(o,r)};const Bt={widehat:"^",widecheck:"\u02c7",widetilde:"~",utilde:"~",overleftarrow:"\u2190",underleftarrow:"\u2190",xleftarrow:"\u2190",overrightarrow:"\u2192",underrightarrow:"\u2192",xrightarrow:"\u2192",underbrace:"\u23df",overbrace:"\u23de",overgroup:"\u23e0",undergroup:"\u23e1",overleftrightarrow:"\u2194",underleftrightarrow:"\u2194",xleftrightarrow:"\u2194",Overrightarrow:"\u21d2",xRightarrow:"\u21d2",overleftharpoon:"\u21bc",xleftharpoonup:"\u21bc",overrightharpoon:"\u21c0",xrightharpoonup:"\u21c0",xLeftarrow:"\u21d0",xLeftrightarrow:"\u21d4",xhookleftarrow:"\u21a9",xhookrightarrow:"\u21aa",xmapsto:"\u21a6",xrightharpoondown:"\u21c1",xleftharpoondown:"\u21bd",xrightleftharpoons:"\u21cc",xleftrightharpoons:"\u21cb",xtwoheadleftarrow:"\u219e",xtwoheadrightarrow:"\u21a0",xlongequal:"=",xtofrom:"\u21c4",xrightleftarrows:"\u21c4",xrightequilibrium:"\u21cc",xleftequilibrium:"\u21cb","\\cdrightarrow":"\u2192","\\cdleftarrow":"\u2190","\\cdlongequal":"="},Ct={overrightarrow:[["rightarrow"],.888,522,"xMaxYMin"],overleftarrow:[["leftarrow"],.888,522,"xMinYMin"],underrightarrow:[["rightarrow"],.888,522,"xMaxYMin"],underleftarrow:[["leftarrow"],.888,522,"xMinYMin"],xrightarrow:[["rightarrow"],1.469,522,"xMaxYMin"],"\\cdrightarrow":[["rightarrow"],3,522,"xMaxYMin"],xleftarrow:[["leftarrow"],1.469,522,"xMinYMin"],"\\cdleftarrow":[["leftarrow"],3,522,"xMinYMin"],Overrightarrow:[["doublerightarrow"],.888,560,"xMaxYMin"],xRightarrow:[["doublerightarrow"],1.526,560,"xMaxYMin"],xLeftarrow:[["doubleleftarrow"],1.526,560,"xMinYMin"],overleftharpoon:[["leftharpoon"],.888,522,"xMinYMin"],xleftharpoonup:[["leftharpoon"],.888,522,"xMinYMin"],xleftharpoondown:[["leftharpoondown"],.888,522,"xMinYMin"],overrightharpoon:[["rightharpoon"],.888,522,"xMaxYMin"],xrightharpoonup:[["rightharpoon"],.888,522,"xMaxYMin"],xrightharpoondown:[["rightharpoondown"],.888,522,"xMaxYMin"],xlongequal:[["longequal"],.888,334,"xMinYMin"],"\\cdlongequal":[["longequal"],3,334,"xMinYMin"],xtwoheadleftarrow:[["twoheadleftarrow"],.888,334,"xMinYMin"],xtwoheadrightarrow:[["twoheadrightarrow"],.888,334,"xMaxYMin"],overleftrightarrow:[["leftarrow","rightarrow"],.888,522],overbrace:[["leftbrace","midbrace","rightbrace"],1.6,548],underbrace:[["leftbraceunder","midbraceunder","rightbraceunder"],1.6,548],underleftrightarrow:[["leftarrow","rightarrow"],.888,522],xleftrightarrow:[["leftarrow","rightarrow"],1.75,522],xLeftrightarrow:[["doubleleftarrow","doublerightarrow"],1.75,560],xrightleftharpoons:[["leftharpoondownplus","rightharpoonplus"],1.75,716],xleftrightharpoons:[["leftharpoonplus","rightharpoondownplus"],1.75,716],xhookleftarrow:[["leftarrow","righthook"],1.08,522],xhookrightarrow:[["lefthook","rightarrow"],1.08,522],overlinesegment:[["leftlinesegment","rightlinesegment"],.888,522],underlinesegment:[["leftlinesegment","rightlinesegment"],.888,522],overgroup:[["leftgroup","rightgroup"],.888,342],undergroup:[["leftgroupunder","rightgroupunder"],.888,342],xmapsto:[["leftmapsto","rightarrow"],1.5,522],xtofrom:[["leftToFrom","rightToFrom"],1.75,528],xrightleftarrows:[["baraboveleftarrow","rightarrowabovebar"],1.75,901],xrightequilibrium:[["baraboveshortleftharpoon","rightharpoonaboveshortbar"],1.75,716],xleftequilibrium:[["shortbaraboveleftharpoon","shortrightharpoonabovebar"],1.75,716]};var Nt=function(e,t,r,n,o){let s;const i=e.height+e.depth+r+n;if(/fbox|color|angl/.test(t)){if(s=Pe.makeSpan(["stretchy",t],[],o),"fbox"===t){const e=o.color&&o.getColor();e&&(s.style.borderColor=e)}}else{const e=[];/^[bx]cancel$/.test(t)&&e.push(new ee({x1:"0",y1:"0",x2:"100%",y2:"100%","stroke-width":"0.046em"})),/^x?cancel$/.test(t)&&e.push(new ee({x1:"0",y1:"100%",x2:"100%",y2:"0","stroke-width":"0.046em"}));const r=new J(e,{width:"100%",height:F(i)});s=Pe.makeSvgSpan([],[r],o)}return s.height=i,s.style.height=F(i),s},qt=function(e){const t=new ft.MathNode("mo",[new ft.TextNode(Bt[e.replace(/^\\/,"")])]);return t.setAttribute("stretchy","true"),t},It=function(e,t){const{span:r,minWidth:n,height:o}=function(){let r=4e5;const n=e.label.slice(1);if(l.contains(["widehat","widecheck","widetilde","utilde"],n)){const s="ordgroup"===(o=e.base).type?o.body.length:1;let i,a,l;if(s>5)"widehat"===n||"widecheck"===n?(i=420,r=2364,l=.42,a=n+"4"):(i=312,r=2340,l=.34,a="tilde4");else{const e=[1,1,2,2,3,3][s];"widehat"===n||"widecheck"===n?(r=[0,1062,2364,2364,2364][e],i=[0,239,300,360,420][e],l=[0,.24,.3,.3,.36,.42][e],a=n+e):(r=[0,600,1033,2339,2340][e],i=[0,260,286,306,312][e],l=[0,.26,.286,.3,.306,.34][e],a="tilde"+e)}const h=new Q(a),c=new J([h],{width:"100%",height:F(l),viewBox:"0 0 "+r+" "+i,preserveAspectRatio:"none"});return{span:Pe.makeSvgSpan([],[c],t),minWidth:0,height:l}}{const e=[],o=Ct[n],[s,i,a]=o,l=a/1e3,h=s.length;let c,m;if(1===h){c=["hide-tail"],m=[o[3]]}else if(2===h)c=["halfarrow-left","halfarrow-right"],m=["xMinYMin","xMaxYMin"];else{if(3!==h)throw new Error("Correct katexImagesData or update code here to support\n                    "+h+" children.");c=["brace-left","brace-center","brace-right"],m=["xMinYMin","xMidYMin","xMaxYMin"]}for(let n=0;n<h;n++){const o=new Q(s[n]),p=new J([o],{width:"400em",height:F(l),viewBox:"0 0 "+r+" "+a,preserveAspectRatio:m[n]+" slice"}),u=Pe.makeSvgSpan([c[n]],[p],t);if(1===h)return{span:u,minWidth:i,height:l};u.style.height=F(l),e.push(u)}return{span:Pe.makeSpan(["stretchy"],e,t),minWidth:i,height:l}}var o}();return r.height=o,r.style.height=F(o),n>0&&(r.style.minWidth=F(n)),r};function Rt(e,t){if(!e||e.type!==t)throw new Error("Expected node of type "+t+", but got "+(e?"node of type "+e.type:String(e)));return e}function Ht(e){const t=Ot(e);if(!t)throw new Error("Expected node of symbol group type, but got "+(e?"node of type "+e.type:String(e)));return t}function Ot(e){return e&&("atom"===e.type||ne.hasOwnProperty(e.type))?e:null}const Et=(e,t)=>{let r,n,o;e&&"supsub"===e.type?(n=Rt(e.base,"accent"),r=n.base,e.base=r,o=function(e){if(e instanceof _)return e;throw new Error("Expected span<HtmlDomNode> but got "+String(e)+".")}(ct(e,t)),e.base=n):(n=Rt(e,"accent"),r=n.base);const s=ct(r,t.havingCrampedStyle());let i=0;if(n.isShifty&&l.isCharacterBox(r)){const e=l.getBaseElem(r);i=te(ct(e,t.havingCrampedStyle())).skew}const a="\\c"===n.label;let h,c=a?s.height+s.depth:Math.min(s.height,t.fontMetrics().xHeight);if(n.isStretchy)h=It(n,t),h=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"elem",elem:h,wrapperClasses:["svg-align"],wrapperStyle:i>0?{width:"calc(100% - "+F(2*i)+")",marginLeft:F(2*i)}:void 0}]},t);else{let e,r;"\\vec"===n.label?(e=Pe.staticSvg("vec",t),r=Pe.svgData.vec[1]):(e=Pe.makeOrd({mode:n.mode,text:n.label},t,"textord"),e=te(e),e.italic=0,r=e.width,a&&(c+=e.depth)),h=Pe.makeSpan(["accent-body"],[e]);const o="\\textcircled"===n.label;o&&(h.classes.push("accent-full"),c=s.height);let l=i;o||(l-=r/2),h.style.left=F(l),"\\textcircled"===n.label&&(h.style.top=".2em"),h=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"kern",size:-c},{type:"elem",elem:h}]},t)}const m=Pe.makeSpan(["mord","accent"],[h],t);return o?(o.children[0]=m,o.height=Math.max(m.height,o.height),o.classes[0]="mord",o):m},Lt=(e,t)=>{const r=e.isStretchy?qt(e.label):new ft.MathNode("mo",[bt(e.label,e.mode)]),n=new ft.MathNode("mover",[St(e.base,t),r]);return n.setAttribute("accent","true"),n},Dt=new RegExp(["\\acute","\\grave","\\ddot","\\tilde","\\bar","\\breve","\\check","\\hat","\\vec","\\dot","\\mathring"].map((e=>"\\"+e)).join("|"));$e({type:"accent",names:["\\acute","\\grave","\\ddot","\\tilde","\\bar","\\breve","\\check","\\hat","\\vec","\\dot","\\mathring","\\widecheck","\\widehat","\\widetilde","\\overrightarrow","\\overleftarrow","\\Overrightarrow","\\overleftrightarrow","\\overgroup","\\overlinesegment","\\overleftharpoon","\\overrightharpoon"],props:{numArgs:1},handler:(e,t)=>{const r=Ke(t[0]),n=!Dt.test(e.funcName),o=!n||"\\widehat"===e.funcName||"\\widetilde"===e.funcName||"\\widecheck"===e.funcName;return{type:"accent",mode:e.parser.mode,label:e.funcName,isStretchy:n,isShifty:o,base:r}},htmlBuilder:Et,mathmlBuilder:Lt}),$e({type:"accent",names:["\\'","\\`","\\^","\\~","\\=","\\u","\\.",'\\"',"\\c","\\r","\\H","\\v","\\textcircled"],props:{numArgs:1,allowedInText:!0,allowedInMath:!0,argTypes:["primitive"]},handler:(e,t)=>{const r=t[0];let n=e.parser.mode;return"math"===n&&(e.parser.settings.reportNonstrict("mathVsTextAccents","LaTeX's accent "+e.funcName+" works only in text mode"),n="text"),{type:"accent",mode:n,label:e.funcName,isStretchy:!1,isShifty:!0,base:r}},htmlBuilder:Et,mathmlBuilder:Lt}),$e({type:"accentUnder",names:["\\underleftarrow","\\underrightarrow","\\underleftrightarrow","\\undergroup","\\underlinesegment","\\utilde"],props:{numArgs:1},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0];return{type:"accentUnder",mode:r.mode,label:n,base:o}},htmlBuilder:(e,t)=>{const r=ct(e.base,t),n=It(e,t),o="\\utilde"===e.label?.12:0,s=Pe.makeVList({positionType:"top",positionData:r.height,children:[{type:"elem",elem:n,wrapperClasses:["svg-align"]},{type:"kern",size:o},{type:"elem",elem:r}]},t);return Pe.makeSpan(["mord","accentunder"],[s],t)},mathmlBuilder:(e,t)=>{const r=qt(e.label),n=new ft.MathNode("munder",[St(e.base,t),r]);return n.setAttribute("accentunder","true"),n}});const Vt=e=>{const t=new ft.MathNode("mpadded",e?[e]:[]);return t.setAttribute("width","+0.6em"),t.setAttribute("lspace","0.3em"),t};$e({type:"xArrow",names:["\\xleftarrow","\\xrightarrow","\\xLeftarrow","\\xRightarrow","\\xleftrightarrow","\\xLeftrightarrow","\\xhookleftarrow","\\xhookrightarrow","\\xmapsto","\\xrightharpoondown","\\xrightharpoonup","\\xleftharpoondown","\\xleftharpoonup","\\xrightleftharpoons","\\xleftrightharpoons","\\xlongequal","\\xtwoheadrightarrow","\\xtwoheadleftarrow","\\xtofrom","\\xrightleftarrows","\\xrightequilibrium","\\xleftequilibrium","\\\\cdrightarrow","\\\\cdleftarrow","\\\\cdlongequal"],props:{numArgs:1,numOptionalArgs:1},handler(e,t,r){let{parser:n,funcName:o}=e;return{type:"xArrow",mode:n.mode,label:o,body:t[0],below:r[0]}},htmlBuilder(e,t){const r=t.style;let n=t.havingStyle(r.sup());const o=Pe.wrapFragment(ct(e.body,n,t),t),s="\\x"===e.label.slice(0,2)?"x":"cd";let i;o.classes.push(s+"-arrow-pad"),e.below&&(n=t.havingStyle(r.sub()),i=Pe.wrapFragment(ct(e.below,n,t),t),i.classes.push(s+"-arrow-pad"));const a=It(e,t),l=-t.fontMetrics().axisHeight+.5*a.height;let h,c=-t.fontMetrics().axisHeight-.5*a.height-.111;if((o.depth>.25||"\\xleftequilibrium"===e.label)&&(c-=o.depth),i){const e=-t.fontMetrics().axisHeight+i.height+.5*a.height+.111;h=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:o,shift:c},{type:"elem",elem:a,shift:l},{type:"elem",elem:i,shift:e}]},t)}else h=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:o,shift:c},{type:"elem",elem:a,shift:l}]},t);return h.children[0].children[0].children[1].classes.push("svg-align"),Pe.makeSpan(["mrel","x-arrow"],[h],t)},mathmlBuilder(e,t){const r=qt(e.label);let n;if(r.setAttribute("minsize","x"===e.label.charAt(0)?"1.75em":"3.0em"),e.body){const o=Vt(St(e.body,t));if(e.below){const s=Vt(St(e.below,t));n=new ft.MathNode("munderover",[r,s,o])}else n=new ft.MathNode("mover",[r,o])}else if(e.below){const o=Vt(St(e.below,t));n=new ft.MathNode("munder",[r,o])}else n=Vt(),n=new ft.MathNode("mover",[r,n]);return n}});const Pt=Pe.makeSpan;function Ft(e,t){const r=ot(e.body,t,!0);return Pt([e.mclass],r,t)}function Gt(e,t){let r;const n=vt(e.body,t);return"minner"===e.mclass?r=new ft.MathNode("mpadded",n):"mord"===e.mclass?e.isCharacterBox?(r=n[0],r.type="mi"):r=new ft.MathNode("mi",n):(e.isCharacterBox?(r=n[0],r.type="mo"):r=new ft.MathNode("mo",n),"mbin"===e.mclass?(r.attributes.lspace="0.22em",r.attributes.rspace="0.22em"):"mpunct"===e.mclass?(r.attributes.lspace="0em",r.attributes.rspace="0.17em"):"mopen"===e.mclass||"mclose"===e.mclass?(r.attributes.lspace="0em",r.attributes.rspace="0em"):"minner"===e.mclass&&(r.attributes.lspace="0.0556em",r.attributes.width="+0.1111em")),r}$e({type:"mclass",names:["\\mathord","\\mathbin","\\mathrel","\\mathopen","\\mathclose","\\mathpunct","\\mathinner"],props:{numArgs:1,primitive:!0},handler(e,t){let{parser:r,funcName:n}=e;const o=t[0];return{type:"mclass",mode:r.mode,mclass:"m"+n.slice(5),body:Je(o),isCharacterBox:l.isCharacterBox(o)}},htmlBuilder:Ft,mathmlBuilder:Gt});const Ut=e=>{const t="ordgroup"===e.type&&e.body.length?e.body[0]:e;return"atom"!==t.type||"bin"!==t.family&&"rel"!==t.family?"mord":"m"+t.family};$e({type:"mclass",names:["\\@binrel"],props:{numArgs:2},handler(e,t){let{parser:r}=e;return{type:"mclass",mode:r.mode,mclass:Ut(t[0]),body:Je(t[1]),isCharacterBox:l.isCharacterBox(t[1])}}}),$e({type:"mclass",names:["\\stackrel","\\overset","\\underset"],props:{numArgs:2},handler(e,t){let{parser:r,funcName:n}=e;const o=t[1],s=t[0];let i;i="\\stackrel"!==n?Ut(o):"mrel";const a={type:"op",mode:o.mode,limits:!0,alwaysHandleSupSub:!0,parentIsSupSub:!1,symbol:!1,suppressBaseShift:"\\stackrel"!==n,body:Je(o)},h={type:"supsub",mode:s.mode,base:a,sup:"\\underset"===n?null:s,sub:"\\underset"===n?s:null};return{type:"mclass",mode:r.mode,mclass:i,body:[h],isCharacterBox:l.isCharacterBox(h)}},htmlBuilder:Ft,mathmlBuilder:Gt}),$e({type:"pmb",names:["\\pmb"],props:{numArgs:1,allowedInText:!0},handler(e,t){let{parser:r}=e;return{type:"pmb",mode:r.mode,mclass:Ut(t[0]),body:Je(t[0])}},htmlBuilder(e,t){const r=ot(e.body,t,!0),n=Pe.makeSpan([e.mclass],r,t);return n.style.textShadow="0.02em 0.01em 0.04px",n},mathmlBuilder(e,t){const r=vt(e.body,t),n=new ft.MathNode("mstyle",r);return n.setAttribute("style","text-shadow: 0.02em 0.01em 0.04px"),n}});const Yt={">":"\\\\cdrightarrow","<":"\\\\cdleftarrow","=":"\\\\cdlongequal",A:"\\uparrow",V:"\\downarrow","|":"\\Vert",".":"no arrow"},Xt=e=>"textord"===e.type&&"@"===e.text;function Wt(e,t,r){const n=Yt[e];switch(n){case"\\\\cdrightarrow":case"\\\\cdleftarrow":return r.callFunction(n,[t[0]],[t[1]]);case"\\uparrow":case"\\downarrow":{const e={type:"atom",text:n,mode:"math",family:"rel"},o={type:"ordgroup",mode:"math",body:[r.callFunction("\\\\cdleft",[t[0]],[]),r.callFunction("\\Big",[e],[]),r.callFunction("\\\\cdright",[t[1]],[])]};return r.callFunction("\\\\cdparent",[o],[])}case"\\\\cdlongequal":return r.callFunction("\\\\cdlongequal",[],[]);case"\\Vert":{const e={type:"textord",text:"\\Vert",mode:"math"};return r.callFunction("\\Big",[e],[])}default:return{type:"textord",text:" ",mode:"math"}}}$e({type:"cdlabel",names:["\\\\cdleft","\\\\cdright"],props:{numArgs:1},handler(e,t){let{parser:r,funcName:n}=e;return{type:"cdlabel",mode:r.mode,side:n.slice(4),label:t[0]}},htmlBuilder(e,t){const r=t.havingStyle(t.style.sup()),n=Pe.wrapFragment(ct(e.label,r,t),t);return n.classes.push("cd-label-"+e.side),n.style.bottom=F(.8-n.depth),n.height=0,n.depth=0,n},mathmlBuilder(e,t){let r=new ft.MathNode("mrow",[St(e.label,t)]);return r=new ft.MathNode("mpadded",[r]),r.setAttribute("width","0"),"left"===e.side&&r.setAttribute("lspace","-1width"),r.setAttribute("voffset","0.7em"),r=new ft.MathNode("mstyle",[r]),r.setAttribute("displaystyle","false"),r.setAttribute("scriptlevel","1"),r}}),$e({type:"cdlabelparent",names:["\\\\cdparent"],props:{numArgs:1},handler(e,t){let{parser:r}=e;return{type:"cdlabelparent",mode:r.mode,fragment:t[0]}},htmlBuilder(e,t){const r=Pe.wrapFragment(ct(e.fragment,t),t);return r.classes.push("cd-vert-arrow"),r},mathmlBuilder(e,t){return new ft.MathNode("mrow",[St(e.fragment,t)])}}),$e({type:"textord",names:["\\@char"],props:{numArgs:1,allowedInText:!0},handler(e,t){let{parser:r}=e;const o=Rt(t[0],"ordgroup").body;let s="";for(let e=0;e<o.length;e++){s+=Rt(o[e],"textord").text}let i,a=parseInt(s);if(isNaN(a))throw new n("\\@char has non-numeric argument "+s);if(a<0||a>=1114111)throw new n("\\@char with invalid code point "+s);return a<=65535?i=String.fromCharCode(a):(a-=65536,i=String.fromCharCode(55296+(a>>10),56320+(1023&a))),{type:"textord",mode:r.mode,text:i}}});const _t=(e,t)=>{const r=ot(e.body,t.withColor(e.color),!1);return Pe.makeFragment(r)},jt=(e,t)=>{const r=vt(e.body,t.withColor(e.color)),n=new ft.MathNode("mstyle",r);return n.setAttribute("mathcolor",e.color),n};$e({type:"color",names:["\\textcolor"],props:{numArgs:2,allowedInText:!0,argTypes:["color","original"]},handler(e,t){let{parser:r}=e;const n=Rt(t[0],"color-token").color,o=t[1];return{type:"color",mode:r.mode,color:n,body:Je(o)}},htmlBuilder:_t,mathmlBuilder:jt}),$e({type:"color",names:["\\color"],props:{numArgs:1,allowedInText:!0,argTypes:["color"]},handler(e,t){let{parser:r,breakOnTokenText:n}=e;const o=Rt(t[0],"color-token").color;r.gullet.macros.set("\\current@color",o);const s=r.parseExpression(!0,n);return{type:"color",mode:r.mode,color:o,body:s}},htmlBuilder:_t,mathmlBuilder:jt}),$e({type:"cr",names:["\\\\"],props:{numArgs:0,numOptionalArgs:0,allowedInText:!0},handler(e,t,r){let{parser:n}=e;const o="["===n.gullet.future().text?n.parseSizeGroup(!0):null,s=!n.settings.displayMode||!n.settings.useStrictBehavior("newLineInDisplayMode","In LaTeX, \\\\ or \\newline does nothing in display mode");return{type:"cr",mode:n.mode,newLine:s,size:o&&Rt(o,"size").value}},htmlBuilder(e,t){const r=Pe.makeSpan(["mspace"],[],t);return e.newLine&&(r.classes.push("newline"),e.size&&(r.style.marginTop=F(P(e.size,t)))),r},mathmlBuilder(e,t){const r=new ft.MathNode("mspace");return e.newLine&&(r.setAttribute("linebreak","newline"),e.size&&r.setAttribute("height",F(P(e.size,t)))),r}});const $t={"\\global":"\\global","\\long":"\\\\globallong","\\\\globallong":"\\\\globallong","\\def":"\\gdef","\\gdef":"\\gdef","\\edef":"\\xdef","\\xdef":"\\xdef","\\let":"\\\\globallet","\\futurelet":"\\\\globalfuture"},Zt=e=>{const t=e.text;if(/^(?:[\\{}$&#^_]|EOF)$/.test(t))throw new n("Expected a control sequence",e);return t},Kt=(e,t,r,n)=>{let o=e.gullet.macros.get(r.text);null==o&&(r.noexpand=!0,o={tokens:[r],numArgs:0,unexpandable:!e.gullet.isExpandable(r.text)}),e.gullet.macros.set(t,o,n)};$e({type:"internal",names:["\\global","\\long","\\\\globallong"],props:{numArgs:0,allowedInText:!0},handler(e){let{parser:t,funcName:r}=e;t.consumeSpaces();const o=t.fetch();if($t[o.text])return"\\global"!==r&&"\\\\globallong"!==r||(o.text=$t[o.text]),Rt(t.parseFunction(),"internal");throw new n("Invalid token after macro prefix",o)}}),$e({type:"internal",names:["\\def","\\gdef","\\edef","\\xdef"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(e){let{parser:t,funcName:r}=e,o=t.gullet.popToken();const s=o.text;if(/^(?:[\\{}$&#^_]|EOF)$/.test(s))throw new n("Expected a control sequence",o);let i,a=0;const l=[[]];for(;"{"!==t.gullet.future().text;)if(o=t.gullet.popToken(),"#"===o.text){if("{"===t.gullet.future().text){i=t.gullet.future(),l[a].push("{");break}if(o=t.gullet.popToken(),!/^[1-9]$/.test(o.text))throw new n('Invalid argument number "'+o.text+'"');if(parseInt(o.text)!==a+1)throw new n('Argument number "'+o.text+'" out of order');a++,l.push([])}else{if("EOF"===o.text)throw new n("Expected a macro definition");l[a].push(o.text)}let{tokens:h}=t.gullet.consumeArg();return i&&h.unshift(i),"\\edef"!==r&&"\\xdef"!==r||(h=t.gullet.expandTokens(h),h.reverse()),t.gullet.macros.set(s,{tokens:h,numArgs:a,delimiters:l},r===$t[r]),{type:"internal",mode:t.mode}}}),$e({type:"internal",names:["\\let","\\\\globallet"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(e){let{parser:t,funcName:r}=e;const n=Zt(t.gullet.popToken());t.gullet.consumeSpaces();const o=(e=>{let t=e.gullet.popToken();return"="===t.text&&(t=e.gullet.popToken()," "===t.text&&(t=e.gullet.popToken())),t})(t);return Kt(t,n,o,"\\\\globallet"===r),{type:"internal",mode:t.mode}}}),$e({type:"internal",names:["\\futurelet","\\\\globalfuture"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(e){let{parser:t,funcName:r}=e;const n=Zt(t.gullet.popToken()),o=t.gullet.popToken(),s=t.gullet.popToken();return Kt(t,n,s,"\\\\globalfuture"===r),t.gullet.pushToken(s),t.gullet.pushToken(o),{type:"internal",mode:t.mode}}});const Jt=function(e,t,r){const n=N(se.math[e]&&se.math[e].replace||e,t,r);if(!n)throw new Error("Unsupported symbol "+e+" and font size "+t+".");return n},Qt=function(e,t,r,n){const o=r.havingBaseStyle(t),s=Pe.makeSpan(n.concat(o.sizingClasses(r)),[e],r),i=o.sizeMultiplier/r.sizeMultiplier;return s.height*=i,s.depth*=i,s.maxFontSize=o.sizeMultiplier,s},er=function(e,t,r){const n=t.havingBaseStyle(r),o=(1-t.sizeMultiplier/n.sizeMultiplier)*t.fontMetrics().axisHeight;e.classes.push("delimcenter"),e.style.top=F(o),e.height-=o,e.depth+=o},tr=function(e,t,r,n,o,s){const i=function(e,t,r,n){return Pe.makeSymbol(e,"Size"+t+"-Regular",r,n)}(e,t,o,n),a=Qt(Pe.makeSpan(["delimsizing","size"+t],[i],n),w.TEXT,n,s);return r&&er(a,n,w.TEXT),a},rr=function(e,t,r){let n;n="Size1-Regular"===t?"delim-size1":"delim-size4";return{type:"elem",elem:Pe.makeSpan(["delimsizinginner",n],[Pe.makeSpan([],[Pe.makeSymbol(e,t,r)])])}},nr=function(e,t,r){const n=T["Size4-Regular"][e.charCodeAt(0)]?T["Size4-Regular"][e.charCodeAt(0)][4]:T["Size1-Regular"][e.charCodeAt(0)][4],o=new Q("inner",function(e,t){switch(e){case"\u239c":return"M291 0 H417 V"+t+" H291z M291 0 H417 V"+t+" H291z";case"\u2223":return"M145 0 H188 V"+t+" H145z M145 0 H188 V"+t+" H145z";case"\u2225":return"M145 0 H188 V"+t+" H145z M145 0 H188 V"+t+" H145zM367 0 H410 V"+t+" H367z M367 0 H410 V"+t+" H367z";case"\u239f":return"M457 0 H583 V"+t+" H457z M457 0 H583 V"+t+" H457z";case"\u23a2":return"M319 0 H403 V"+t+" H319z M319 0 H403 V"+t+" H319z";case"\u23a5":return"M263 0 H347 V"+t+" H263z M263 0 H347 V"+t+" H263z";case"\u23aa":return"M384 0 H504 V"+t+" H384z M384 0 H504 V"+t+" H384z";case"\u23d0":return"M312 0 H355 V"+t+" H312z M312 0 H355 V"+t+" H312z";case"\u2016":return"M257 0 H300 V"+t+" H257z M257 0 H300 V"+t+" H257zM478 0 H521 V"+t+" H478z M478 0 H521 V"+t+" H478z";default:return""}}(e,Math.round(1e3*t))),s=new J([o],{width:F(n),height:F(t),style:"width:"+F(n),viewBox:"0 0 "+1e3*n+" "+Math.round(1e3*t),preserveAspectRatio:"xMinYMin"}),i=Pe.makeSvgSpan([],[s],r);return i.height=t,i.style.height=F(t),i.style.width=F(n),{type:"elem",elem:i}},or={type:"kern",size:-.008},sr=["|","\\lvert","\\rvert","\\vert"],ir=["\\|","\\lVert","\\rVert","\\Vert"],ar=function(e,t,r,n,o,s){let i,a,h,c,m="",p=0;i=h=c=e,a=null;let u="Size1-Regular";"\\uparrow"===e?h=c="\u23d0":"\\Uparrow"===e?h=c="\u2016":"\\downarrow"===e?i=h="\u23d0":"\\Downarrow"===e?i=h="\u2016":"\\updownarrow"===e?(i="\\uparrow",h="\u23d0",c="\\downarrow"):"\\Updownarrow"===e?(i="\\Uparrow",h="\u2016",c="\\Downarrow"):l.contains(sr,e)?(h="\u2223",m="vert",p=333):l.contains(ir,e)?(h="\u2225",m="doublevert",p=556):"["===e||"\\lbrack"===e?(i="\u23a1",h="\u23a2",c="\u23a3",u="Size4-Regular",m="lbrack",p=667):"]"===e||"\\rbrack"===e?(i="\u23a4",h="\u23a5",c="\u23a6",u="Size4-Regular",m="rbrack",p=667):"\\lfloor"===e||"\u230a"===e?(h=i="\u23a2",c="\u23a3",u="Size4-Regular",m="lfloor",p=667):"\\lceil"===e||"\u2308"===e?(i="\u23a1",h=c="\u23a2",u="Size4-Regular",m="lceil",p=667):"\\rfloor"===e||"\u230b"===e?(h=i="\u23a5",c="\u23a6",u="Size4-Regular",m="rfloor",p=667):"\\rceil"===e||"\u2309"===e?(i="\u23a4",h=c="\u23a5",u="Size4-Regular",m="rceil",p=667):"("===e||"\\lparen"===e?(i="\u239b",h="\u239c",c="\u239d",u="Size4-Regular",m="lparen",p=875):")"===e||"\\rparen"===e?(i="\u239e",h="\u239f",c="\u23a0",u="Size4-Regular",m="rparen",p=875):"\\{"===e||"\\lbrace"===e?(i="\u23a7",a="\u23a8",c="\u23a9",h="\u23aa",u="Size4-Regular"):"\\}"===e||"\\rbrace"===e?(i="\u23ab",a="\u23ac",c="\u23ad",h="\u23aa",u="Size4-Regular"):"\\lgroup"===e||"\u27ee"===e?(i="\u23a7",c="\u23a9",h="\u23aa",u="Size4-Regular"):"\\rgroup"===e||"\u27ef"===e?(i="\u23ab",c="\u23ad",h="\u23aa",u="Size4-Regular"):"\\lmoustache"===e||"\u23b0"===e?(i="\u23a7",c="\u23ad",h="\u23aa",u="Size4-Regular"):"\\rmoustache"!==e&&"\u23b1"!==e||(i="\u23ab",c="\u23a9",h="\u23aa",u="Size4-Regular");const d=Jt(i,u,o),g=d.height+d.depth,f=Jt(h,u,o),b=f.height+f.depth,y=Jt(c,u,o),x=y.height+y.depth;let v=0,k=1;if(null!==a){const e=Jt(a,u,o);v=e.height+e.depth,k=2}const S=g+x+v,M=S+Math.max(0,Math.ceil((t-S)/(k*b)))*k*b;let z=n.fontMetrics().axisHeight;r&&(z*=n.sizeMultiplier);const A=M/2-z,T=[];if(m.length>0){const e=M-g-x,t=Math.round(1e3*M),r=function(e,t){switch(e){case"lbrack":return"M403 1759 V84 H666 V0 H319 V1759 v"+t+" v1759 h347 v-84\nH403z M403 1759 V0 H319 V1759 v"+t+" v1759 h84z";case"rbrack":return"M347 1759 V0 H0 V84 H263 V1759 v"+t+" v1759 H0 v84 H347z\nM347 1759 V0 H263 V1759 v"+t+" v1759 h84z";case"vert":return"M145 15 v585 v"+t+" v585 c2.667,10,9.667,15,21,15\nc10,0,16.667,-5,20,-15 v-585 v"+-t+" v-585 c-2.667,-10,-9.667,-15,-21,-15\nc-10,0,-16.667,5,-20,15z M188 15 H145 v585 v"+t+" v585 h43z";case"doublevert":return"M145 15 v585 v"+t+" v585 c2.667,10,9.667,15,21,15\nc10,0,16.667,-5,20,-15 v-585 v"+-t+" v-585 c-2.667,-10,-9.667,-15,-21,-15\nc-10,0,-16.667,5,-20,15z M188 15 H145 v585 v"+t+" v585 h43z\nM367 15 v585 v"+t+" v585 c2.667,10,9.667,15,21,15\nc10,0,16.667,-5,20,-15 v-585 v"+-t+" v-585 c-2.667,-10,-9.667,-15,-21,-15\nc-10,0,-16.667,5,-20,15z M410 15 H367 v585 v"+t+" v585 h43z";case"lfloor":return"M319 602 V0 H403 V602 v"+t+" v1715 h263 v84 H319z\nMM319 602 V0 H403 V602 v"+t+" v1715 H319z";case"rfloor":return"M319 602 V0 H403 V602 v"+t+" v1799 H0 v-84 H319z\nMM319 602 V0 H403 V602 v"+t+" v1715 H319z";case"lceil":return"M403 1759 V84 H666 V0 H319 V1759 v"+t+" v602 h84z\nM403 1759 V0 H319 V1759 v"+t+" v602 h84z";case"rceil":return"M347 1759 V0 H0 V84 H263 V1759 v"+t+" v602 h84z\nM347 1759 V0 h-84 V1759 v"+t+" v602 h84z";case"lparen":return"M863,9c0,-2,-2,-5,-6,-9c0,0,-17,0,-17,0c-12.7,0,-19.3,0.3,-20,1\nc-5.3,5.3,-10.3,11,-15,17c-242.7,294.7,-395.3,682,-458,1162c-21.3,163.3,-33.3,349,\n-36,557 l0,"+(t+84)+"c0.2,6,0,26,0,60c2,159.3,10,310.7,24,454c53.3,528,210,\n949.7,470,1265c4.7,6,9.7,11.7,15,17c0.7,0.7,7,1,19,1c0,0,18,0,18,0c4,-4,6,-7,6,-9\nc0,-2.7,-3.3,-8.7,-10,-18c-135.3,-192.7,-235.5,-414.3,-300.5,-665c-65,-250.7,-102.5,\n-544.7,-112.5,-882c-2,-104,-3,-167,-3,-189\nl0,-"+(t+92)+"c0,-162.7,5.7,-314,17,-454c20.7,-272,63.7,-513,129,-723c65.3,\n-210,155.3,-396.3,270,-559c6.7,-9.3,10,-15.3,10,-18z";case"rparen":return"M76,0c-16.7,0,-25,3,-25,9c0,2,2,6.3,6,13c21.3,28.7,42.3,60.3,\n63,95c96.7,156.7,172.8,332.5,228.5,527.5c55.7,195,92.8,416.5,111.5,664.5\nc11.3,139.3,17,290.7,17,454c0,28,1.7,43,3.3,45l0,"+(t+9)+"\nc-3,4,-3.3,16.7,-3.3,38c0,162,-5.7,313.7,-17,455c-18.7,248,-55.8,469.3,-111.5,664\nc-55.7,194.7,-131.8,370.3,-228.5,527c-20.7,34.7,-41.7,66.3,-63,95c-2,3.3,-4,7,-6,11\nc0,7.3,5.7,11,17,11c0,0,11,0,11,0c9.3,0,14.3,-0.3,15,-1c5.3,-5.3,10.3,-11,15,-17\nc242.7,-294.7,395.3,-681.7,458,-1161c21.3,-164.7,33.3,-350.7,36,-558\nl0,-"+(t+144)+"c-2,-159.3,-10,-310.7,-24,-454c-53.3,-528,-210,-949.7,\n-470,-1265c-4.7,-6,-9.7,-11.7,-15,-17c-0.7,-0.7,-6.7,-1,-18,-1z";default:throw new Error("Unknown stretchy delimiter.")}}(m,Math.round(1e3*e)),o=new Q(m,r),s=(p/1e3).toFixed(3)+"em",i=(t/1e3).toFixed(3)+"em",a=new J([o],{width:s,height:i,viewBox:"0 0 "+p+" "+t}),l=Pe.makeSvgSpan([],[a],n);l.height=t/1e3,l.style.width=s,l.style.height=i,T.push({type:"elem",elem:l})}else{if(T.push(rr(c,u,o)),T.push(or),null===a){const e=M-g-x+.016;T.push(nr(h,e,n))}else{const e=(M-g-x-v)/2+.016;T.push(nr(h,e,n)),T.push(or),T.push(rr(a,u,o)),T.push(or),T.push(nr(h,e,n))}T.push(or),T.push(rr(i,u,o))}const B=n.havingBaseStyle(w.TEXT),C=Pe.makeVList({positionType:"bottom",positionData:A,children:T},B);return Qt(Pe.makeSpan(["delimsizing","mult"],[C],B),w.TEXT,n,s)},lr=.08,hr=function(e,t,r,n,o){const s=function(e,t,r){t*=1e3;let n="";switch(e){case"sqrtMain":n=function(e,t){return"M95,"+(622+e+t)+"\nc-2.7,0,-7.17,-2.7,-13.5,-8c-5.8,-5.3,-9.5,-10,-9.5,-14\nc0,-2,0.3,-3.3,1,-4c1.3,-2.7,23.83,-20.7,67.5,-54\nc44.2,-33.3,65.8,-50.3,66.5,-51c1.3,-1.3,3,-2,5,-2c4.7,0,8.7,3.3,12,10\ns173,378,173,378c0.7,0,35.3,-71,104,-213c68.7,-142,137.5,-285,206.5,-429\nc69,-144,104.5,-217.7,106.5,-221\nl"+e/2.075+" -"+e+"\nc5.3,-9.3,12,-14,20,-14\nH400000v"+(40+e)+"H845.2724\ns-225.272,467,-225.272,467s-235,486,-235,486c-2.7,4.7,-9,7,-19,7\nc-6,0,-10,-1,-12,-3s-194,-422,-194,-422s-65,47,-65,47z\nM"+(834+e)+" "+t+"h400000v"+(40+e)+"h-400000z"}(t,M);break;case"sqrtSize1":n=function(e,t){return"M263,"+(601+e+t)+"c0.7,0,18,39.7,52,119\nc34,79.3,68.167,158.7,102.5,238c34.3,79.3,51.8,119.3,52.5,120\nc340,-704.7,510.7,-1060.3,512,-1067\nl"+e/2.084+" -"+e+"\nc4.7,-7.3,11,-11,19,-11\nH40000v"+(40+e)+"H1012.3\ns-271.3,567,-271.3,567c-38.7,80.7,-84,175,-136,283c-52,108,-89.167,185.3,-111.5,232\nc-22.3,46.7,-33.8,70.3,-34.5,71c-4.7,4.7,-12.3,7,-23,7s-12,-1,-12,-1\ns-109,-253,-109,-253c-72.7,-168,-109.3,-252,-110,-252c-10.7,8,-22,16.7,-34,26\nc-22,17.3,-33.3,26,-34,26s-26,-26,-26,-26s76,-59,76,-59s76,-60,76,-60z\nM"+(1001+e)+" "+t+"h400000v"+(40+e)+"h-400000z"}(t,M);break;case"sqrtSize2":n=function(e,t){return"M983 "+(10+e+t)+"\nl"+e/3.13+" -"+e+"\nc4,-6.7,10,-10,18,-10 H400000v"+(40+e)+"\nH1013.1s-83.4,268,-264.1,840c-180.7,572,-277,876.3,-289,913c-4.7,4.7,-12.7,7,-24,7\ns-12,0,-12,0c-1.3,-3.3,-3.7,-11.7,-7,-25c-35.3,-125.3,-106.7,-373.3,-214,-744\nc-10,12,-21,25,-33,39s-32,39,-32,39c-6,-5.3,-15,-14,-27,-26s25,-30,25,-30\nc26.7,-32.7,52,-63,76,-91s52,-60,52,-60s208,722,208,722\nc56,-175.3,126.3,-397.3,211,-666c84.7,-268.7,153.8,-488.2,207.5,-658.5\nc53.7,-170.3,84.5,-266.8,92.5,-289.5z\nM"+(1001+e)+" "+t+"h400000v"+(40+e)+"h-400000z"}(t,M);break;case"sqrtSize3":n=function(e,t){return"M424,"+(2398+e+t)+"\nc-1.3,-0.7,-38.5,-172,-111.5,-514c-73,-342,-109.8,-513.3,-110.5,-514\nc0,-2,-10.7,14.3,-32,49c-4.7,7.3,-9.8,15.7,-15.5,25c-5.7,9.3,-9.8,16,-12.5,20\ns-5,7,-5,7c-4,-3.3,-8.3,-7.7,-13,-13s-13,-13,-13,-13s76,-122,76,-122s77,-121,77,-121\ns209,968,209,968c0,-2,84.7,-361.7,254,-1079c169.3,-717.3,254.7,-1077.7,256,-1081\nl"+e/4.223+" -"+e+"c4,-6.7,10,-10,18,-10 H400000\nv"+(40+e)+"H1014.6\ns-87.3,378.7,-272.6,1166c-185.3,787.3,-279.3,1182.3,-282,1185\nc-2,6,-10,9,-24,9\nc-8,0,-12,-0.7,-12,-2z M"+(1001+e)+" "+t+"\nh400000v"+(40+e)+"h-400000z"}(t,M);break;case"sqrtSize4":n=function(e,t){return"M473,"+(2713+e+t)+"\nc339.3,-1799.3,509.3,-2700,510,-2702 l"+e/5.298+" -"+e+"\nc3.3,-7.3,9.3,-11,18,-11 H400000v"+(40+e)+"H1017.7\ns-90.5,478,-276.2,1466c-185.7,988,-279.5,1483,-281.5,1485c-2,6,-10,9,-24,9\nc-8,0,-12,-0.7,-12,-2c0,-1.3,-5.3,-32,-16,-92c-50.7,-293.3,-119.7,-693.3,-207,-1200\nc0,-1.3,-5.3,8.7,-16,30c-10.7,21.3,-21.3,42.7,-32,64s-16,33,-16,33s-26,-26,-26,-26\ns76,-153,76,-153s77,-151,77,-151c0.7,0.7,35.7,202,105,604c67.3,400.7,102,602.7,104,\n606zM"+(1001+e)+" "+t+"h400000v"+(40+e)+"H1017.7z"}(t,M);break;case"sqrtTall":n=function(e,t,r){return"M702 "+(e+t)+"H400000"+(40+e)+"\nH742v"+(r-54-t-e)+"l-4 4-4 4c-.667.7 -2 1.5-4 2.5s-4.167 1.833-6.5 2.5-5.5 1-9.5 1\nh-12l-28-84c-16.667-52-96.667 -294.333-240-727l-212 -643 -85 170\nc-4-3.333-8.333-7.667-13 -13l-13-13l77-155 77-156c66 199.333 139 419.667\n219 661 l218 661zM702 "+t+"H400000v"+(40+e)+"H742z"}(t,M,r)}return n}(e,n,r),i=new Q(e,s),a=new J([i],{width:"400em",height:F(t),viewBox:"0 0 400000 "+r,preserveAspectRatio:"xMinYMin slice"});return Pe.makeSvgSpan(["hide-tail"],[a],o)},cr=["(","\\lparen",")","\\rparen","[","\\lbrack","]","\\rbrack","\\{","\\lbrace","\\}","\\rbrace","\\lfloor","\\rfloor","\u230a","\u230b","\\lceil","\\rceil","\u2308","\u2309","\\surd"],mr=["\\uparrow","\\downarrow","\\updownarrow","\\Uparrow","\\Downarrow","\\Updownarrow","|","\\|","\\vert","\\Vert","\\lvert","\\rvert","\\lVert","\\rVert","\\lgroup","\\rgroup","\u27ee","\u27ef","\\lmoustache","\\rmoustache","\u23b0","\u23b1"],pr=["<",">","\\langle","\\rangle","/","\\backslash","\\lt","\\gt"],ur=[0,1.2,1.8,2.4,3],dr=[{type:"small",style:w.SCRIPTSCRIPT},{type:"small",style:w.SCRIPT},{type:"small",style:w.TEXT},{type:"large",size:1},{type:"large",size:2},{type:"large",size:3},{type:"large",size:4}],gr=[{type:"small",style:w.SCRIPTSCRIPT},{type:"small",style:w.SCRIPT},{type:"small",style:w.TEXT},{type:"stack"}],fr=[{type:"small",style:w.SCRIPTSCRIPT},{type:"small",style:w.SCRIPT},{type:"small",style:w.TEXT},{type:"large",size:1},{type:"large",size:2},{type:"large",size:3},{type:"large",size:4},{type:"stack"}],br=function(e){if("small"===e.type)return"Main-Regular";if("large"===e.type)return"Size"+e.size+"-Regular";if("stack"===e.type)return"Size4-Regular";throw new Error("Add support for delim type '"+e.type+"' here.")},yr=function(e,t,r,n){for(let o=Math.min(2,3-n.style.size);o<r.length&&"stack"!==r[o].type;o++){const s=Jt(e,br(r[o]),"math");let i=s.height+s.depth;if("small"===r[o].type){i*=n.havingBaseStyle(r[o].style).sizeMultiplier}if(i>t)return r[o]}return r[r.length-1]},xr=function(e,t,r,n,o,s){let i;"<"===e||"\\lt"===e||"\u27e8"===e?e="\\langle":">"!==e&&"\\gt"!==e&&"\u27e9"!==e||(e="\\rangle"),i=l.contains(pr,e)?dr:l.contains(cr,e)?fr:gr;const a=yr(e,t,i,n);return"small"===a.type?function(e,t,r,n,o,s){const i=Pe.makeSymbol(e,"Main-Regular",o,n),a=Qt(i,t,n,s);return r&&er(a,n,t),a}(e,a.style,r,n,o,s):"large"===a.type?tr(e,a.size,r,n,o,s):ar(e,t,r,n,o,s)};var wr={sqrtImage:function(e,t){const r=t.havingBaseSizing(),n=yr("\\surd",e*r.sizeMultiplier,fr,r);let o=r.sizeMultiplier;const s=Math.max(0,t.minRuleThickness-t.fontMetrics().sqrtRuleThickness);let i,a,l=0,h=0,c=0;return"small"===n.type?(c=1e3+1e3*s+80,e<1?o=1:e<1.4&&(o=.7),l=(1+s+lr)/o,h=(1+s)/o,i=hr("sqrtMain",l,c,s,t),i.style.minWidth="0.853em",a=.833/o):"large"===n.type?(c=1080*ur[n.size],h=(ur[n.size]+s)/o,l=(ur[n.size]+s+lr)/o,i=hr("sqrtSize"+n.size,l,c,s,t),i.style.minWidth="1.02em",a=1/o):(l=e+s+lr,h=e+s,c=Math.floor(1e3*e+s)+80,i=hr("sqrtTall",l,c,s,t),i.style.minWidth="0.742em",a=1.056),i.height=h,i.style.height=F(l),{span:i,advanceWidth:a,ruleWidth:(t.fontMetrics().sqrtRuleThickness+s)*o}},sizedDelim:function(e,t,r,o,s){if("<"===e||"\\lt"===e||"\u27e8"===e?e="\\langle":">"!==e&&"\\gt"!==e&&"\u27e9"!==e||(e="\\rangle"),l.contains(cr,e)||l.contains(pr,e))return tr(e,t,!1,r,o,s);if(l.contains(mr,e))return ar(e,ur[t],!1,r,o,s);throw new n("Illegal delimiter: '"+e+"'")},sizeToMaxHeight:ur,customSizedDelim:xr,leftRightDelim:function(e,t,r,n,o,s){const i=n.fontMetrics().axisHeight*n.sizeMultiplier,a=5/n.fontMetrics().ptPerEm,l=Math.max(t-i,r+i),h=Math.max(l/500*901,2*l-a);return xr(e,h,!0,n,o,s)}};const vr={"\\bigl":{mclass:"mopen",size:1},"\\Bigl":{mclass:"mopen",size:2},"\\biggl":{mclass:"mopen",size:3},"\\Biggl":{mclass:"mopen",size:4},"\\bigr":{mclass:"mclose",size:1},"\\Bigr":{mclass:"mclose",size:2},"\\biggr":{mclass:"mclose",size:3},"\\Biggr":{mclass:"mclose",size:4},"\\bigm":{mclass:"mrel",size:1},"\\Bigm":{mclass:"mrel",size:2},"\\biggm":{mclass:"mrel",size:3},"\\Biggm":{mclass:"mrel",size:4},"\\big":{mclass:"mord",size:1},"\\Big":{mclass:"mord",size:2},"\\bigg":{mclass:"mord",size:3},"\\Bigg":{mclass:"mord",size:4}},kr=["(","\\lparen",")","\\rparen","[","\\lbrack","]","\\rbrack","\\{","\\lbrace","\\}","\\rbrace","\\lfloor","\\rfloor","\u230a","\u230b","\\lceil","\\rceil","\u2308","\u2309","<",">","\\langle","\u27e8","\\rangle","\u27e9","\\lt","\\gt","\\lvert","\\rvert","\\lVert","\\rVert","\\lgroup","\\rgroup","\u27ee","\u27ef","\\lmoustache","\\rmoustache","\u23b0","\u23b1","/","\\backslash","|","\\vert","\\|","\\Vert","\\uparrow","\\Uparrow","\\downarrow","\\Downarrow","\\updownarrow","\\Updownarrow","."];function Sr(e,t){const r=Ot(e);if(r&&l.contains(kr,r.text))return r;throw new n(r?"Invalid delimiter '"+r.text+"' after '"+t.funcName+"'":"Invalid delimiter type '"+e.type+"'",e)}function Mr(e){if(!e.body)throw new Error("Bug: The leftright ParseNode wasn't fully parsed.")}$e({type:"delimsizing",names:["\\bigl","\\Bigl","\\biggl","\\Biggl","\\bigr","\\Bigr","\\biggr","\\Biggr","\\bigm","\\Bigm","\\biggm","\\Biggm","\\big","\\Big","\\bigg","\\Bigg"],props:{numArgs:1,argTypes:["primitive"]},handler:(e,t)=>{const r=Sr(t[0],e);return{type:"delimsizing",mode:e.parser.mode,size:vr[e.funcName].size,mclass:vr[e.funcName].mclass,delim:r.text}},htmlBuilder:(e,t)=>"."===e.delim?Pe.makeSpan([e.mclass]):wr.sizedDelim(e.delim,e.size,t,e.mode,[e.mclass]),mathmlBuilder:e=>{const t=[];"."!==e.delim&&t.push(bt(e.delim,e.mode));const r=new ft.MathNode("mo",t);"mopen"===e.mclass||"mclose"===e.mclass?r.setAttribute("fence","true"):r.setAttribute("fence","false"),r.setAttribute("stretchy","true");const n=F(wr.sizeToMaxHeight[e.size]);return r.setAttribute("minsize",n),r.setAttribute("maxsize",n),r}}),$e({type:"leftright-right",names:["\\right"],props:{numArgs:1,primitive:!0},handler:(e,t)=>{const r=e.parser.gullet.macros.get("\\current@color");if(r&&"string"!=typeof r)throw new n("\\current@color set to non-string in \\right");return{type:"leftright-right",mode:e.parser.mode,delim:Sr(t[0],e).text,color:r}}}),$e({type:"leftright",names:["\\left"],props:{numArgs:1,primitive:!0},handler:(e,t)=>{const r=Sr(t[0],e),n=e.parser;++n.leftrightDepth;const o=n.parseExpression(!1);--n.leftrightDepth,n.expect("\\right",!1);const s=Rt(n.parseFunction(),"leftright-right");return{type:"leftright",mode:n.mode,body:o,left:r.text,right:s.delim,rightColor:s.color}},htmlBuilder:(e,t)=>{Mr(e);const r=ot(e.body,t,!0,["mopen","mclose"]);let n,o,s=0,i=0,a=!1;for(let e=0;e<r.length;e++)r[e].isMiddle?a=!0:(s=Math.max(r[e].height,s),i=Math.max(r[e].depth,i));if(s*=t.sizeMultiplier,i*=t.sizeMultiplier,n="."===e.left?ht(t,["mopen"]):wr.leftRightDelim(e.left,s,i,t,e.mode,["mopen"]),r.unshift(n),a)for(let t=1;t<r.length;t++){const n=r[t].isMiddle;n&&(r[t]=wr.leftRightDelim(n.delim,s,i,n.options,e.mode,[]))}if("."===e.right)o=ht(t,["mclose"]);else{const r=e.rightColor?t.withColor(e.rightColor):t;o=wr.leftRightDelim(e.right,s,i,r,e.mode,["mclose"])}return r.push(o),Pe.makeSpan(["minner"],r,t)},mathmlBuilder:(e,t)=>{Mr(e);const r=vt(e.body,t);if("."!==e.left){const t=new ft.MathNode("mo",[bt(e.left,e.mode)]);t.setAttribute("fence","true"),r.unshift(t)}if("."!==e.right){const t=new ft.MathNode("mo",[bt(e.right,e.mode)]);t.setAttribute("fence","true"),e.rightColor&&t.setAttribute("mathcolor",e.rightColor),r.push(t)}return yt(r)}}),$e({type:"middle",names:["\\middle"],props:{numArgs:1,primitive:!0},handler:(e,t)=>{const r=Sr(t[0],e);if(!e.parser.leftrightDepth)throw new n("\\middle without preceding \\left",r);return{type:"middle",mode:e.parser.mode,delim:r.text}},htmlBuilder:(e,t)=>{let r;if("."===e.delim)r=ht(t,[]);else{r=wr.sizedDelim(e.delim,1,t,e.mode,[]);const n={delim:e.delim,options:t};r.isMiddle=n}return r},mathmlBuilder:(e,t)=>{const r="\\vert"===e.delim||"|"===e.delim?bt("|","text"):bt(e.delim,e.mode),n=new ft.MathNode("mo",[r]);return n.setAttribute("fence","true"),n.setAttribute("lspace","0.05em"),n.setAttribute("rspace","0.05em"),n}});const zr=(e,t)=>{const r=Pe.wrapFragment(ct(e.body,t),t),n=e.label.slice(1);let o,s=t.sizeMultiplier,i=0;const a=l.isCharacterBox(e.body);if("sout"===n)o=Pe.makeSpan(["stretchy","sout"]),o.height=t.fontMetrics().defaultRuleThickness/s,i=-.5*t.fontMetrics().xHeight;else if("phase"===n){const e=P({number:.6,unit:"pt"},t),n=P({number:.35,unit:"ex"},t);s/=t.havingBaseSizing().sizeMultiplier;const a=r.height+r.depth+e+n;r.style.paddingLeft=F(a/2+e);const l=Math.floor(1e3*a*s),c="M400000 "+(h=l)+" H0 L"+h/2+" 0 l65 45 L145 "+(h-80)+" H400000z",m=new J([new Q("phase",c)],{width:"400em",height:F(l/1e3),viewBox:"0 0 400000 "+l,preserveAspectRatio:"xMinYMin slice"});o=Pe.makeSvgSpan(["hide-tail"],[m],t),o.style.height=F(a),i=r.depth+e+n}else{/cancel/.test(n)?a||r.classes.push("cancel-pad"):"angl"===n?r.classes.push("anglpad"):r.classes.push("boxpad");let s=0,l=0,h=0;/box/.test(n)?(h=Math.max(t.fontMetrics().fboxrule,t.minRuleThickness),s=t.fontMetrics().fboxsep+("colorbox"===n?0:h),l=s):"angl"===n?(h=Math.max(t.fontMetrics().defaultRuleThickness,t.minRuleThickness),s=4*h,l=Math.max(0,.25-r.depth)):(s=a?.2:0,l=s),o=Nt(r,n,s,l,t),/fbox|boxed|fcolorbox/.test(n)?(o.style.borderStyle="solid",o.style.borderWidth=F(h)):"angl"===n&&.049!==h&&(o.style.borderTopWidth=F(h),o.style.borderRightWidth=F(h)),i=r.depth+l,e.backgroundColor&&(o.style.backgroundColor=e.backgroundColor,e.borderColor&&(o.style.borderColor=e.borderColor))}var h;let c;if(e.backgroundColor)c=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:o,shift:i},{type:"elem",elem:r,shift:0}]},t);else{const e=/cancel|phase/.test(n)?["svg-align"]:[];c=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:r,shift:0},{type:"elem",elem:o,shift:i,wrapperClasses:e}]},t)}return/cancel/.test(n)&&(c.height=r.height,c.depth=r.depth),/cancel/.test(n)&&!a?Pe.makeSpan(["mord","cancel-lap"],[c],t):Pe.makeSpan(["mord"],[c],t)},Ar=(e,t)=>{let r=0;const n=new ft.MathNode(e.label.indexOf("colorbox")>-1?"mpadded":"menclose",[St(e.body,t)]);switch(e.label){case"\\cancel":n.setAttribute("notation","updiagonalstrike");break;case"\\bcancel":n.setAttribute("notation","downdiagonalstrike");break;case"\\phase":n.setAttribute("notation","phasorangle");break;case"\\sout":n.setAttribute("notation","horizontalstrike");break;case"\\fbox":n.setAttribute("notation","box");break;case"\\angl":n.setAttribute("notation","actuarial");break;case"\\fcolorbox":case"\\colorbox":if(r=t.fontMetrics().fboxsep*t.fontMetrics().ptPerEm,n.setAttribute("width","+"+2*r+"pt"),n.setAttribute("height","+"+2*r+"pt"),n.setAttribute("lspace",r+"pt"),n.setAttribute("voffset",r+"pt"),"\\fcolorbox"===e.label){const r=Math.max(t.fontMetrics().fboxrule,t.minRuleThickness);n.setAttribute("style","border: "+r+"em solid "+String(e.borderColor))}break;case"\\xcancel":n.setAttribute("notation","updiagonalstrike downdiagonalstrike")}return e.backgroundColor&&n.setAttribute("mathbackground",e.backgroundColor),n};$e({type:"enclose",names:["\\colorbox"],props:{numArgs:2,allowedInText:!0,argTypes:["color","text"]},handler(e,t,r){let{parser:n,funcName:o}=e;const s=Rt(t[0],"color-token").color,i=t[1];return{type:"enclose",mode:n.mode,label:o,backgroundColor:s,body:i}},htmlBuilder:zr,mathmlBuilder:Ar}),$e({type:"enclose",names:["\\fcolorbox"],props:{numArgs:3,allowedInText:!0,argTypes:["color","color","text"]},handler(e,t,r){let{parser:n,funcName:o}=e;const s=Rt(t[0],"color-token").color,i=Rt(t[1],"color-token").color,a=t[2];return{type:"enclose",mode:n.mode,label:o,backgroundColor:i,borderColor:s,body:a}},htmlBuilder:zr,mathmlBuilder:Ar}),$e({type:"enclose",names:["\\fbox"],props:{numArgs:1,argTypes:["hbox"],allowedInText:!0},handler(e,t){let{parser:r}=e;return{type:"enclose",mode:r.mode,label:"\\fbox",body:t[0]}}}),$e({type:"enclose",names:["\\cancel","\\bcancel","\\xcancel","\\sout","\\phase"],props:{numArgs:1},handler(e,t){let{parser:r,funcName:n}=e;const o=t[0];return{type:"enclose",mode:r.mode,label:n,body:o}},htmlBuilder:zr,mathmlBuilder:Ar}),$e({type:"enclose",names:["\\angl"],props:{numArgs:1,argTypes:["hbox"],allowedInText:!1},handler(e,t){let{parser:r}=e;return{type:"enclose",mode:r.mode,label:"\\angl",body:t[0]}}});const Tr={};function Br(e){let{type:t,names:r,props:n,handler:o,htmlBuilder:s,mathmlBuilder:i}=e;const a={type:t,numArgs:n.numArgs||0,allowedInText:!1,numOptionalArgs:0,handler:o};for(let e=0;e<r.length;++e)Tr[r[e]]=a;s&&(_e[t]=s),i&&(je[t]=i)}const Cr={};function Nr(e,t){Cr[e]=t}class qr{constructor(e,t,r){this.lexer=void 0,this.start=void 0,this.end=void 0,this.lexer=e,this.start=t,this.end=r}static range(e,t){return t?e&&e.loc&&t.loc&&e.loc.lexer===t.loc.lexer?new qr(e.loc.lexer,e.loc.start,t.loc.end):null:e&&e.loc}}class Ir{constructor(e,t){this.text=void 0,this.loc=void 0,this.noexpand=void 0,this.treatAsRelax=void 0,this.text=e,this.loc=t}range(e,t){return new Ir(t,qr.range(this,e))}}function Rr(e){const t=[];e.consumeSpaces();let r=e.fetch().text;for("\\relax"===r&&(e.consume(),e.consumeSpaces(),r=e.fetch().text);"\\hline"===r||"\\hdashline"===r;)e.consume(),t.push("\\hdashline"===r),e.consumeSpaces(),r=e.fetch().text;return t}const Hr=e=>{if(!e.parser.settings.displayMode)throw new n("{"+e.envName+"} can be used only in display mode.")};function Or(e){if(-1===e.indexOf("ed"))return-1===e.indexOf("*")}function Er(e,t,r){let{hskipBeforeAndAfter:o,addJot:s,cols:i,arraystretch:a,colSeparationType:l,autoTag:h,singleRow:c,emptySingleRow:m,maxNumCols:p,leqno:u}=t;if(e.gullet.beginGroup(),c||e.gullet.macros.set("\\cr","\\\\\\relax"),!a){const t=e.gullet.expandMacroAsText("\\arraystretch");if(null==t)a=1;else if(a=parseFloat(t),!a||a<0)throw new n("Invalid \\arraystretch: "+t)}e.gullet.beginGroup();let d=[];const g=[d],f=[],b=[],y=null!=h?[]:void 0;function x(){h&&e.gullet.macros.set("\\@eqnsw","1",!0)}function w(){y&&(e.gullet.macros.get("\\df@tag")?(y.push(e.subparse([new Ir("\\df@tag")])),e.gullet.macros.set("\\df@tag",void 0,!0)):y.push(Boolean(h)&&"1"===e.gullet.macros.get("\\@eqnsw")))}for(x(),b.push(Rr(e));;){let t=e.parseExpression(!1,c?"\\end":"\\\\");e.gullet.endGroup(),e.gullet.beginGroup(),t={type:"ordgroup",mode:e.mode,body:t},r&&(t={type:"styling",mode:e.mode,style:r,body:[t]}),d.push(t);const o=e.fetch().text;if("&"===o){if(p&&d.length===p){if(c||l)throw new n("Too many tab characters: &",e.nextToken);e.settings.reportNonstrict("textEnv","Too few columns specified in the {array} column argument.")}e.consume()}else{if("\\end"===o){w(),1===d.length&&"styling"===t.type&&0===t.body[0].body.length&&(g.length>1||!m)&&g.pop(),b.length<g.length+1&&b.push([]);break}if("\\\\"!==o)throw new n("Expected & or \\\\ or \\cr or \\end",e.nextToken);{let t;e.consume()," "!==e.gullet.future().text&&(t=e.parseSizeGroup(!0)),f.push(t?t.value:null),w(),b.push(Rr(e)),d=[],g.push(d),x()}}}return e.gullet.endGroup(),e.gullet.endGroup(),{type:"array",mode:e.mode,addJot:s,arraystretch:a,body:g,cols:i,rowGaps:f,hskipBeforeAndAfter:o,hLinesBeforeRow:b,colSeparationType:l,tags:y,leqno:u}}function Lr(e){return"d"===e.slice(0,1)?"display":"text"}const Dr=function(e,t){let r,o;const s=e.body.length,i=e.hLinesBeforeRow;let a=0,h=new Array(s);const c=[],m=Math.max(t.fontMetrics().arrayRuleWidth,t.minRuleThickness),p=1/t.fontMetrics().ptPerEm;let u=5*p;if(e.colSeparationType&&"small"===e.colSeparationType){u=t.havingStyle(w.SCRIPT).sizeMultiplier/t.sizeMultiplier*.2778}const d="CD"===e.colSeparationType?P({number:3,unit:"ex"},t):12*p,g=3*p,f=e.arraystretch*d,b=.7*f,y=.3*f;let x=0;function v(e){for(let t=0;t<e.length;++t)t>0&&(x+=.25),c.push({pos:x,isDashed:e[t]})}for(v(i[0]),r=0;r<e.body.length;++r){const n=e.body[r];let s=b,l=y;a<n.length&&(a=n.length);const c=new Array(n.length);for(o=0;o<n.length;++o){const e=ct(n[o],t);l<e.depth&&(l=e.depth),s<e.height&&(s=e.height),c[o]=e}const m=e.rowGaps[r];let p=0;m&&(p=P(m,t),p>0&&(p+=y,l<p&&(l=p),p=0)),e.addJot&&(l+=g),c.height=s,c.depth=l,x+=s,c.pos=x,x+=l+p,h[r]=c,v(i[r+1])}const k=x/2+t.fontMetrics().axisHeight,S=e.cols||[],M=[];let z,A;const T=[];if(e.tags&&e.tags.some((e=>e)))for(r=0;r<s;++r){const n=h[r],o=n.pos-k,s=e.tags[r];let i;i=!0===s?Pe.makeSpan(["eqn-num"],[],t):!1===s?Pe.makeSpan([],[],t):Pe.makeSpan([],ot(s,t,!0),t),i.depth=n.depth,i.height=n.height,T.push({type:"elem",elem:i,shift:o})}for(o=0,A=0;o<a||A<S.length;++o,++A){let i,c=S[A]||{},p=!0;for(;"separator"===c.type;){if(p||(z=Pe.makeSpan(["arraycolsep"],[]),z.style.width=F(t.fontMetrics().doubleRuleSep),M.push(z)),"|"!==c.separator&&":"!==c.separator)throw new n("Invalid separator type: "+c.separator);{const e="|"===c.separator?"solid":"dashed",r=Pe.makeSpan(["vertical-separator"],[],t);r.style.height=F(x),r.style.borderRightWidth=F(m),r.style.borderRightStyle=e,r.style.margin="0 "+F(-m/2);const n=x-k;n&&(r.style.verticalAlign=F(-n)),M.push(r)}A++,c=S[A]||{},p=!1}if(o>=a)continue;(o>0||e.hskipBeforeAndAfter)&&(i=l.deflt(c.pregap,u),0!==i&&(z=Pe.makeSpan(["arraycolsep"],[]),z.style.width=F(i),M.push(z)));let d=[];for(r=0;r<s;++r){const e=h[r],t=e[o];if(!t)continue;const n=e.pos-k;t.depth=e.depth,t.height=e.height,d.push({type:"elem",elem:t,shift:n})}d=Pe.makeVList({positionType:"individualShift",children:d},t),d=Pe.makeSpan(["col-align-"+(c.align||"c")],[d]),M.push(d),(o<a-1||e.hskipBeforeAndAfter)&&(i=l.deflt(c.postgap,u),0!==i&&(z=Pe.makeSpan(["arraycolsep"],[]),z.style.width=F(i),M.push(z)))}if(h=Pe.makeSpan(["mtable"],M),c.length>0){const e=Pe.makeLineSpan("hline",t,m),r=Pe.makeLineSpan("hdashline",t,m),n=[{type:"elem",elem:h,shift:0}];for(;c.length>0;){const t=c.pop(),o=t.pos-k;t.isDashed?n.push({type:"elem",elem:r,shift:o}):n.push({type:"elem",elem:e,shift:o})}h=Pe.makeVList({positionType:"individualShift",children:n},t)}if(0===T.length)return Pe.makeSpan(["mord"],[h],t);{let e=Pe.makeVList({positionType:"individualShift",children:T},t);return e=Pe.makeSpan(["tag"],[e],t),Pe.makeFragment([h,e])}},Vr={c:"center ",l:"left ",r:"right "},Pr=function(e,t){const r=[],n=new ft.MathNode("mtd",[],["mtr-glue"]),o=new ft.MathNode("mtd",[],["mml-eqn-num"]);for(let s=0;s<e.body.length;s++){const i=e.body[s],a=[];for(let e=0;e<i.length;e++)a.push(new ft.MathNode("mtd",[St(i[e],t)]));e.tags&&e.tags[s]&&(a.unshift(n),a.push(n),e.leqno?a.unshift(o):a.push(o)),r.push(new ft.MathNode("mtr",a))}let s=new ft.MathNode("mtable",r);const i=.5===e.arraystretch?.1:.16+e.arraystretch-1+(e.addJot?.09:0);s.setAttribute("rowspacing",F(i));let a="",l="";if(e.cols&&e.cols.length>0){const t=e.cols;let r="",n=!1,o=0,i=t.length;"separator"===t[0].type&&(a+="top ",o=1),"separator"===t[t.length-1].type&&(a+="bottom ",i-=1);for(let e=o;e<i;e++)"align"===t[e].type?(l+=Vr[t[e].align],n&&(r+="none "),n=!0):"separator"===t[e].type&&n&&(r+="|"===t[e].separator?"solid ":"dashed ",n=!1);s.setAttribute("columnalign",l.trim()),/[sd]/.test(r)&&s.setAttribute("columnlines",r.trim())}if("align"===e.colSeparationType){const t=e.cols||[];let r="";for(let e=1;e<t.length;e++)r+=e%2?"0em ":"1em ";s.setAttribute("columnspacing",r.trim())}else"alignat"===e.colSeparationType||"gather"===e.colSeparationType?s.setAttribute("columnspacing","0em"):"small"===e.colSeparationType?s.setAttribute("columnspacing","0.2778em"):"CD"===e.colSeparationType?s.setAttribute("columnspacing","0.5em"):s.setAttribute("columnspacing","1em");let h="";const c=e.hLinesBeforeRow;a+=c[0].length>0?"left ":"",a+=c[c.length-1].length>0?"right ":"";for(let e=1;e<c.length-1;e++)h+=0===c[e].length?"none ":c[e][0]?"dashed ":"solid ";return/[sd]/.test(h)&&s.setAttribute("rowlines",h.trim()),""!==a&&(s=new ft.MathNode("menclose",[s]),s.setAttribute("notation",a.trim())),e.arraystretch&&e.arraystretch<1&&(s=new ft.MathNode("mstyle",[s]),s.setAttribute("scriptlevel","1")),s},Fr=function(e,t){-1===e.envName.indexOf("ed")&&Hr(e);const r=[],o=e.envName.indexOf("at")>-1?"alignat":"align",s="split"===e.envName,i=Er(e.parser,{cols:r,addJot:!0,autoTag:s?void 0:Or(e.envName),emptySingleRow:!0,colSeparationType:o,maxNumCols:s?2:void 0,leqno:e.parser.settings.leqno},"display");let a,l=0;const h={type:"ordgroup",mode:e.mode,body:[]};if(t[0]&&"ordgroup"===t[0].type){let e="";for(let r=0;r<t[0].body.length;r++){e+=Rt(t[0].body[r],"textord").text}a=Number(e),l=2*a}const c=!l;i.body.forEach((function(e){for(let t=1;t<e.length;t+=2){const r=Rt(e[t],"styling");Rt(r.body[0],"ordgroup").body.unshift(h)}if(c)l<e.length&&(l=e.length);else{const t=e.length/2;if(a<t)throw new n("Too many math in a row: expected "+a+", but got "+t,e[0])}}));for(let e=0;e<l;++e){let t="r",n=0;e%2==1?t="l":e>0&&c&&(n=1),r[e]={type:"align",align:t,pregap:n,postgap:0}}return i.colSeparationType=c?"align":"alignat",i};Br({type:"array",names:["array","darray"],props:{numArgs:1},handler(e,t){const r=(Ot(t[0])?[t[0]]:Rt(t[0],"ordgroup").body).map((function(e){const t=Ht(e).text;if(-1!=="lcr".indexOf(t))return{type:"align",align:t};if("|"===t)return{type:"separator",separator:"|"};if(":"===t)return{type:"separator",separator:":"};throw new n("Unknown column alignment: "+t,e)})),o={cols:r,hskipBeforeAndAfter:!0,maxNumCols:r.length};return Er(e.parser,o,Lr(e.envName))},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["matrix","pmatrix","bmatrix","Bmatrix","vmatrix","Vmatrix","matrix*","pmatrix*","bmatrix*","Bmatrix*","vmatrix*","Vmatrix*"],props:{numArgs:0},handler(e){const t={matrix:null,pmatrix:["(",")"],bmatrix:["[","]"],Bmatrix:["\\{","\\}"],vmatrix:["|","|"],Vmatrix:["\\Vert","\\Vert"]}[e.envName.replace("*","")];let r="c";const o={hskipBeforeAndAfter:!1,cols:[{type:"align",align:r}]};if("*"===e.envName.charAt(e.envName.length-1)){const t=e.parser;if(t.consumeSpaces(),"["===t.fetch().text){if(t.consume(),t.consumeSpaces(),r=t.fetch().text,-1==="lcr".indexOf(r))throw new n("Expected l or c or r",t.nextToken);t.consume(),t.consumeSpaces(),t.expect("]"),t.consume(),o.cols=[{type:"align",align:r}]}}const s=Er(e.parser,o,Lr(e.envName)),i=Math.max(0,...s.body.map((e=>e.length)));return s.cols=new Array(i).fill({type:"align",align:r}),t?{type:"leftright",mode:e.mode,body:[s],left:t[0],right:t[1],rightColor:void 0}:s},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["smallmatrix"],props:{numArgs:0},handler(e){const t=Er(e.parser,{arraystretch:.5},"script");return t.colSeparationType="small",t},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["subarray"],props:{numArgs:1},handler(e,t){const r=(Ot(t[0])?[t[0]]:Rt(t[0],"ordgroup").body).map((function(e){const t=Ht(e).text;if(-1!=="lc".indexOf(t))return{type:"align",align:t};throw new n("Unknown column alignment: "+t,e)}));if(r.length>1)throw new n("{subarray} can contain only one column");let o={cols:r,hskipBeforeAndAfter:!1,arraystretch:.5};if(o=Er(e.parser,o,"script"),o.body.length>0&&o.body[0].length>1)throw new n("{subarray} can contain only one column");return o},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["cases","dcases","rcases","drcases"],props:{numArgs:0},handler(e){const t=Er(e.parser,{arraystretch:1.2,cols:[{type:"align",align:"l",pregap:0,postgap:1},{type:"align",align:"l",pregap:0,postgap:0}]},Lr(e.envName));return{type:"leftright",mode:e.mode,body:[t],left:e.envName.indexOf("r")>-1?".":"\\{",right:e.envName.indexOf("r")>-1?"\\}":".",rightColor:void 0}},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["align","align*","aligned","split"],props:{numArgs:0},handler:Fr,htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["gathered","gather","gather*"],props:{numArgs:0},handler(e){l.contains(["gather","gather*"],e.envName)&&Hr(e);const t={cols:[{type:"align",align:"c"}],addJot:!0,colSeparationType:"gather",autoTag:Or(e.envName),emptySingleRow:!0,leqno:e.parser.settings.leqno};return Er(e.parser,t,"display")},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["alignat","alignat*","alignedat"],props:{numArgs:1},handler:Fr,htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["equation","equation*"],props:{numArgs:0},handler(e){Hr(e);const t={autoTag:Or(e.envName),emptySingleRow:!0,singleRow:!0,maxNumCols:1,leqno:e.parser.settings.leqno};return Er(e.parser,t,"display")},htmlBuilder:Dr,mathmlBuilder:Pr}),Br({type:"array",names:["CD"],props:{numArgs:0},handler(e){return Hr(e),function(e){const t=[];for(e.gullet.beginGroup(),e.gullet.macros.set("\\cr","\\\\\\relax"),e.gullet.beginGroup();;){t.push(e.parseExpression(!1,"\\\\")),e.gullet.endGroup(),e.gullet.beginGroup();const r=e.fetch().text;if("&"!==r&&"\\\\"!==r){if("\\end"===r){0===t[t.length-1].length&&t.pop();break}throw new n("Expected \\\\ or \\cr or \\end",e.nextToken)}e.consume()}let r=[];const o=[r];for(let a=0;a<t.length;a++){const l=t[a];let h={type:"styling",body:[],mode:"math",style:"display"};for(let t=0;t<l.length;t++)if(Xt(l[t])){r.push(h),t+=1;const o=Ht(l[t]).text,a=new Array(2);if(a[0]={type:"ordgroup",mode:"math",body:[]},a[1]={type:"ordgroup",mode:"math",body:[]},"=|.".indexOf(o)>-1);else{if(!("<>AV".indexOf(o)>-1))throw new n('Expected one of "<>AV=|." after @',l[t]);for(let e=0;e<2;e++){let r=!0;for(let h=t+1;h<l.length;h++){if(i=o,("mathord"===(s=l[h]).type||"atom"===s.type)&&s.text===i){r=!1,t=h;break}if(Xt(l[h]))throw new n("Missing a "+o+" character to complete a CD arrow.",l[h]);a[e].body.push(l[h])}if(r)throw new n("Missing a "+o+" character to complete a CD arrow.",l[t])}}const c={type:"styling",body:[Wt(o,a,e)],mode:"math",style:"display"};r.push(c),h={type:"styling",body:[],mode:"math",style:"display"}}else h.body.push(l[t]);a%2==0?r.push(h):r.shift(),r=[],o.push(r)}var s,i;return e.gullet.endGroup(),e.gullet.endGroup(),{type:"array",mode:"math",body:o,arraystretch:1,addJot:!0,rowGaps:[null],cols:new Array(o[0].length).fill({type:"align",align:"c",pregap:.25,postgap:.25}),colSeparationType:"CD",hLinesBeforeRow:new Array(o.length+1).fill([])}}(e.parser)},htmlBuilder:Dr,mathmlBuilder:Pr}),Nr("\\nonumber","\\gdef\\@eqnsw{0}"),Nr("\\notag","\\nonumber"),$e({type:"text",names:["\\hline","\\hdashline"],props:{numArgs:0,allowedInText:!0,allowedInMath:!0},handler(e,t){throw new n(e.funcName+" valid only within array environment")}});var Gr=Tr;$e({type:"environment",names:["\\begin","\\end"],props:{numArgs:1,argTypes:["text"]},handler(e,t){let{parser:r,funcName:o}=e;const s=t[0];if("ordgroup"!==s.type)throw new n("Invalid environment name",s);let i="";for(let e=0;e<s.body.length;++e)i+=Rt(s.body[e],"textord").text;if("\\begin"===o){if(!Gr.hasOwnProperty(i))throw new n("No such environment: "+i,s);const e=Gr[i],{args:t,optArgs:o}=r.parseArguments("\\begin{"+i+"}",e),a={mode:r.mode,envName:i,parser:r},l=e.handler(a,t,o);r.expect("\\end",!1);const h=r.nextToken,c=Rt(r.parseFunction(),"environment");if(c.name!==i)throw new n("Mismatch: \\begin{"+i+"} matched by \\end{"+c.name+"}",h);return l}return{type:"environment",mode:r.mode,name:i,nameGroup:s}}});const Ur=(e,t)=>{const r=e.font,n=t.withFont(r);return ct(e.body,n)},Yr=(e,t)=>{const r=e.font,n=t.withFont(r);return St(e.body,n)},Xr={"\\Bbb":"\\mathbb","\\bold":"\\mathbf","\\frak":"\\mathfrak","\\bm":"\\boldsymbol"};$e({type:"font",names:["\\mathrm","\\mathit","\\mathbf","\\mathnormal","\\mathsfit","\\mathbb","\\mathcal","\\mathfrak","\\mathscr","\\mathsf","\\mathtt","\\Bbb","\\bold","\\frak"],props:{numArgs:1,allowedInArgument:!0},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=Ke(t[0]);let s=n;return s in Xr&&(s=Xr[s]),{type:"font",mode:r.mode,font:s.slice(1),body:o}},htmlBuilder:Ur,mathmlBuilder:Yr}),$e({type:"mclass",names:["\\boldsymbol","\\bm"],props:{numArgs:1},handler:(e,t)=>{let{parser:r}=e;const n=t[0],o=l.isCharacterBox(n);return{type:"mclass",mode:r.mode,mclass:Ut(n),body:[{type:"font",mode:r.mode,font:"boldsymbol",body:n}],isCharacterBox:o}}}),$e({type:"font",names:["\\rm","\\sf","\\tt","\\bf","\\it","\\cal"],props:{numArgs:0,allowedInText:!0},handler:(e,t)=>{let{parser:r,funcName:n,breakOnTokenText:o}=e;const{mode:s}=r,i=r.parseExpression(!0,o);return{type:"font",mode:s,font:"math"+n.slice(1),body:{type:"ordgroup",mode:r.mode,body:i}}},htmlBuilder:Ur,mathmlBuilder:Yr});const Wr=(e,t)=>{let r=t;return"display"===e?r=r.id>=w.SCRIPT.id?r.text():w.DISPLAY:"text"===e&&r.size===w.DISPLAY.size?r=w.TEXT:"script"===e?r=w.SCRIPT:"scriptscript"===e&&(r=w.SCRIPTSCRIPT),r},_r=(e,t)=>{const r=Wr(e.size,t.style),n=r.fracNum(),o=r.fracDen();let s;s=t.havingStyle(n);const i=ct(e.numer,s,t);if(e.continued){const e=8.5/t.fontMetrics().ptPerEm,r=3.5/t.fontMetrics().ptPerEm;i.height=i.height<e?e:i.height,i.depth=i.depth<r?r:i.depth}s=t.havingStyle(o);const a=ct(e.denom,s,t);let l,h,c,m,p,u,d,g,f,b;if(e.hasBarLine?(e.barSize?(h=P(e.barSize,t),l=Pe.makeLineSpan("frac-line",t,h)):l=Pe.makeLineSpan("frac-line",t),h=l.height,c=l.height):(l=null,h=0,c=t.fontMetrics().defaultRuleThickness),r.size===w.DISPLAY.size||"display"===e.size?(m=t.fontMetrics().num1,p=h>0?3*c:7*c,u=t.fontMetrics().denom1):(h>0?(m=t.fontMetrics().num2,p=c):(m=t.fontMetrics().num3,p=3*c),u=t.fontMetrics().denom2),l){const e=t.fontMetrics().axisHeight;m-i.depth-(e+.5*h)<p&&(m+=p-(m-i.depth-(e+.5*h))),e-.5*h-(a.height-u)<p&&(u+=p-(e-.5*h-(a.height-u)));const r=-(e-.5*h);d=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:a,shift:u},{type:"elem",elem:l,shift:r},{type:"elem",elem:i,shift:-m}]},t)}else{const e=m-i.depth-(a.height-u);e<p&&(m+=.5*(p-e),u+=.5*(p-e)),d=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:a,shift:u},{type:"elem",elem:i,shift:-m}]},t)}return s=t.havingStyle(r),d.height*=s.sizeMultiplier/t.sizeMultiplier,d.depth*=s.sizeMultiplier/t.sizeMultiplier,g=r.size===w.DISPLAY.size?t.fontMetrics().delim1:r.size===w.SCRIPTSCRIPT.size?t.havingStyle(w.SCRIPT).fontMetrics().delim2:t.fontMetrics().delim2,f=null==e.leftDelim?ht(t,["mopen"]):wr.customSizedDelim(e.leftDelim,g,!0,t.havingStyle(r),e.mode,["mopen"]),b=e.continued?Pe.makeSpan([]):null==e.rightDelim?ht(t,["mclose"]):wr.customSizedDelim(e.rightDelim,g,!0,t.havingStyle(r),e.mode,["mclose"]),Pe.makeSpan(["mord"].concat(s.sizingClasses(t)),[f,Pe.makeSpan(["mfrac"],[d]),b],t)},jr=(e,t)=>{let r=new ft.MathNode("mfrac",[St(e.numer,t),St(e.denom,t)]);if(e.hasBarLine){if(e.barSize){const n=P(e.barSize,t);r.setAttribute("linethickness",F(n))}}else r.setAttribute("linethickness","0px");const n=Wr(e.size,t.style);if(n.size!==t.style.size){r=new ft.MathNode("mstyle",[r]);const e=n.size===w.DISPLAY.size?"true":"false";r.setAttribute("displaystyle",e),r.setAttribute("scriptlevel","0")}if(null!=e.leftDelim||null!=e.rightDelim){const t=[];if(null!=e.leftDelim){const r=new ft.MathNode("mo",[new ft.TextNode(e.leftDelim.replace("\\",""))]);r.setAttribute("fence","true"),t.push(r)}if(t.push(r),null!=e.rightDelim){const r=new ft.MathNode("mo",[new ft.TextNode(e.rightDelim.replace("\\",""))]);r.setAttribute("fence","true"),t.push(r)}return yt(t)}return r};$e({type:"genfrac",names:["\\dfrac","\\frac","\\tfrac","\\dbinom","\\binom","\\tbinom","\\\\atopfrac","\\\\bracefrac","\\\\brackfrac"],props:{numArgs:2,allowedInArgument:!0},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0],s=t[1];let i,a=null,l=null,h="auto";switch(n){case"\\dfrac":case"\\frac":case"\\tfrac":i=!0;break;case"\\\\atopfrac":i=!1;break;case"\\dbinom":case"\\binom":case"\\tbinom":i=!1,a="(",l=")";break;case"\\\\bracefrac":i=!1,a="\\{",l="\\}";break;case"\\\\brackfrac":i=!1,a="[",l="]";break;default:throw new Error("Unrecognized genfrac command")}switch(n){case"\\dfrac":case"\\dbinom":h="display";break;case"\\tfrac":case"\\tbinom":h="text"}return{type:"genfrac",mode:r.mode,continued:!1,numer:o,denom:s,hasBarLine:i,leftDelim:a,rightDelim:l,size:h,barSize:null}},htmlBuilder:_r,mathmlBuilder:jr}),$e({type:"genfrac",names:["\\cfrac"],props:{numArgs:2},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0],s=t[1];return{type:"genfrac",mode:r.mode,continued:!0,numer:o,denom:s,hasBarLine:!0,leftDelim:null,rightDelim:null,size:"display",barSize:null}}}),$e({type:"infix",names:["\\over","\\choose","\\atop","\\brace","\\brack"],props:{numArgs:0,infix:!0},handler(e){let t,{parser:r,funcName:n,token:o}=e;switch(n){case"\\over":t="\\frac";break;case"\\choose":t="\\binom";break;case"\\atop":t="\\\\atopfrac";break;case"\\brace":t="\\\\bracefrac";break;case"\\brack":t="\\\\brackfrac";break;default:throw new Error("Unrecognized infix genfrac command")}return{type:"infix",mode:r.mode,replaceWith:t,token:o}}});const $r=["display","text","script","scriptscript"],Zr=function(e){let t=null;return e.length>0&&(t=e,t="."===t?null:t),t};$e({type:"genfrac",names:["\\genfrac"],props:{numArgs:6,allowedInArgument:!0,argTypes:["math","math","size","text","math","math"]},handler(e,t){let{parser:r}=e;const n=t[4],o=t[5],s=Ke(t[0]),i="atom"===s.type&&"open"===s.family?Zr(s.text):null,a=Ke(t[1]),l="atom"===a.type&&"close"===a.family?Zr(a.text):null,h=Rt(t[2],"size");let c,m=null;h.isBlank?c=!0:(m=h.value,c=m.number>0);let p="auto",u=t[3];if("ordgroup"===u.type){if(u.body.length>0){const e=Rt(u.body[0],"textord");p=$r[Number(e.text)]}}else u=Rt(u,"textord"),p=$r[Number(u.text)];return{type:"genfrac",mode:r.mode,numer:n,denom:o,continued:!1,hasBarLine:c,barSize:m,leftDelim:i,rightDelim:l,size:p}},htmlBuilder:_r,mathmlBuilder:jr}),$e({type:"infix",names:["\\above"],props:{numArgs:1,argTypes:["size"],infix:!0},handler(e,t){let{parser:r,funcName:n,token:o}=e;return{type:"infix",mode:r.mode,replaceWith:"\\\\abovefrac",size:Rt(t[0],"size").value,token:o}}}),$e({type:"genfrac",names:["\\\\abovefrac"],props:{numArgs:3,argTypes:["math","size","math"]},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0],s=function(e){if(!e)throw new Error("Expected non-null, but got "+String(e));return e}(Rt(t[1],"infix").size),i=t[2],a=s.number>0;return{type:"genfrac",mode:r.mode,numer:o,denom:i,continued:!1,hasBarLine:a,barSize:s,leftDelim:null,rightDelim:null,size:"auto"}},htmlBuilder:_r,mathmlBuilder:jr});const Kr=(e,t)=>{const r=t.style;let n,o;"supsub"===e.type?(n=e.sup?ct(e.sup,t.havingStyle(r.sup()),t):ct(e.sub,t.havingStyle(r.sub()),t),o=Rt(e.base,"horizBrace")):o=Rt(e,"horizBrace");const s=ct(o.base,t.havingBaseStyle(w.DISPLAY)),i=It(o,t);let a;if(o.isOver?(a=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:s},{type:"kern",size:.1},{type:"elem",elem:i}]},t),a.children[0].children[0].children[1].classes.push("svg-align")):(a=Pe.makeVList({positionType:"bottom",positionData:s.depth+.1+i.height,children:[{type:"elem",elem:i},{type:"kern",size:.1},{type:"elem",elem:s}]},t),a.children[0].children[0].children[0].classes.push("svg-align")),n){const e=Pe.makeSpan(["mord",o.isOver?"mover":"munder"],[a],t);a=o.isOver?Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:e},{type:"kern",size:.2},{type:"elem",elem:n}]},t):Pe.makeVList({positionType:"bottom",positionData:e.depth+.2+n.height+n.depth,children:[{type:"elem",elem:n},{type:"kern",size:.2},{type:"elem",elem:e}]},t)}return Pe.makeSpan(["mord",o.isOver?"mover":"munder"],[a],t)};$e({type:"horizBrace",names:["\\overbrace","\\underbrace"],props:{numArgs:1},handler(e,t){let{parser:r,funcName:n}=e;return{type:"horizBrace",mode:r.mode,label:n,isOver:/^\\over/.test(n),base:t[0]}},htmlBuilder:Kr,mathmlBuilder:(e,t)=>{const r=qt(e.label);return new ft.MathNode(e.isOver?"mover":"munder",[St(e.base,t),r])}}),$e({type:"href",names:["\\href"],props:{numArgs:2,argTypes:["url","original"],allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;const n=t[1],o=Rt(t[0],"url").url;return r.settings.isTrusted({command:"\\href",url:o})?{type:"href",mode:r.mode,href:o,body:Je(n)}:r.formatUnsupportedCmd("\\href")},htmlBuilder:(e,t)=>{const r=ot(e.body,t,!1);return Pe.makeAnchor(e.href,[],r,t)},mathmlBuilder:(e,t)=>{let r=kt(e.body,t);return r instanceof dt||(r=new dt("mrow",[r])),r.setAttribute("href",e.href),r}}),$e({type:"href",names:["\\url"],props:{numArgs:1,argTypes:["url"],allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;const n=Rt(t[0],"url").url;if(!r.settings.isTrusted({command:"\\url",url:n}))return r.formatUnsupportedCmd("\\url");const o=[];for(let e=0;e<n.length;e++){let t=n[e];"~"===t&&(t="\\textasciitilde"),o.push({type:"textord",mode:"text",text:t})}const s={type:"text",mode:r.mode,font:"\\texttt",body:o};return{type:"href",mode:r.mode,href:n,body:Je(s)}}}),$e({type:"hbox",names:["\\hbox"],props:{numArgs:1,argTypes:["text"],allowedInText:!0,primitive:!0},handler(e,t){let{parser:r}=e;return{type:"hbox",mode:r.mode,body:Je(t[0])}},htmlBuilder(e,t){const r=ot(e.body,t,!1);return Pe.makeFragment(r)},mathmlBuilder(e,t){return new ft.MathNode("mrow",vt(e.body,t))}}),$e({type:"html",names:["\\htmlClass","\\htmlId","\\htmlStyle","\\htmlData"],props:{numArgs:2,argTypes:["raw","original"],allowedInText:!0},handler:(e,t)=>{let{parser:r,funcName:o,token:s}=e;const i=Rt(t[0],"raw").string,a=t[1];let l;r.settings.strict&&r.settings.reportNonstrict("htmlExtension","HTML extension is disabled on strict mode");const h={};switch(o){case"\\htmlClass":h.class=i,l={command:"\\htmlClass",class:i};break;case"\\htmlId":h.id=i,l={command:"\\htmlId",id:i};break;case"\\htmlStyle":h.style=i,l={command:"\\htmlStyle",style:i};break;case"\\htmlData":{const e=i.split(",");for(let t=0;t<e.length;t++){const r=e[t].split("=");if(2!==r.length)throw new n("Error parsing key-value for \\htmlData");h["data-"+r[0].trim()]=r[1].trim()}l={command:"\\htmlData",attributes:h};break}default:throw new Error("Unrecognized html command")}return r.settings.isTrusted(l)?{type:"html",mode:r.mode,attributes:h,body:Je(a)}:r.formatUnsupportedCmd(o)},htmlBuilder:(e,t)=>{const r=ot(e.body,t,!1),n=["enclosing"];e.attributes.class&&n.push(...e.attributes.class.trim().split(/\s+/));const o=Pe.makeSpan(n,r,t);for(const t in e.attributes)"class"!==t&&e.attributes.hasOwnProperty(t)&&o.setAttribute(t,e.attributes[t]);return o},mathmlBuilder:(e,t)=>kt(e.body,t)}),$e({type:"htmlmathml",names:["\\html@mathml"],props:{numArgs:2,allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;return{type:"htmlmathml",mode:r.mode,html:Je(t[0]),mathml:Je(t[1])}},htmlBuilder:(e,t)=>{const r=ot(e.html,t,!1);return Pe.makeFragment(r)},mathmlBuilder:(e,t)=>kt(e.mathml,t)});const Jr=function(e){if(/^[-+]? *(\d+(\.\d*)?|\.\d+)$/.test(e))return{number:+e,unit:"bp"};{const t=/([-+]?) *(\d+(?:\.\d*)?|\.\d+) *([a-z]{2})/.exec(e);if(!t)throw new n("Invalid size: '"+e+"' in \\includegraphics");const r={number:+(t[1]+t[2]),unit:t[3]};if(!V(r))throw new n("Invalid unit: '"+r.unit+"' in \\includegraphics.");return r}};$e({type:"includegraphics",names:["\\includegraphics"],props:{numArgs:1,numOptionalArgs:1,argTypes:["raw","url"],allowedInText:!1},handler:(e,t,r)=>{let{parser:o}=e,s={number:0,unit:"em"},i={number:.9,unit:"em"},a={number:0,unit:"em"},l="";if(r[0]){const e=Rt(r[0],"raw").string.split(",");for(let t=0;t<e.length;t++){const r=e[t].split("=");if(2===r.length){const e=r[1].trim();switch(r[0].trim()){case"alt":l=e;break;case"width":s=Jr(e);break;case"height":i=Jr(e);break;case"totalheight":a=Jr(e);break;default:throw new n("Invalid key: '"+r[0]+"' in \\includegraphics.")}}}}const h=Rt(t[0],"url").url;return""===l&&(l=h,l=l.replace(/^.*[\\/]/,""),l=l.substring(0,l.lastIndexOf("."))),o.settings.isTrusted({command:"\\includegraphics",url:h})?{type:"includegraphics",mode:o.mode,alt:l,width:s,height:i,totalheight:a,src:h}:o.formatUnsupportedCmd("\\includegraphics")},htmlBuilder:(e,t)=>{const r=P(e.height,t);let n=0;e.totalheight.number>0&&(n=P(e.totalheight,t)-r);let o=0;e.width.number>0&&(o=P(e.width,t));const s={height:F(r+n)};o>0&&(s.width=F(o)),n>0&&(s.verticalAlign=F(-n));const i=new $(e.src,e.alt,s);return i.height=r,i.depth=n,i},mathmlBuilder:(e,t)=>{const r=new ft.MathNode("mglyph",[]);r.setAttribute("alt",e.alt);const n=P(e.height,t);let o=0;if(e.totalheight.number>0&&(o=P(e.totalheight,t)-n,r.setAttribute("valign",F(-o))),r.setAttribute("height",F(n+o)),e.width.number>0){const n=P(e.width,t);r.setAttribute("width",F(n))}return r.setAttribute("src",e.src),r}}),$e({type:"kern",names:["\\kern","\\mkern","\\hskip","\\mskip"],props:{numArgs:1,argTypes:["size"],primitive:!0,allowedInText:!0},handler(e,t){let{parser:r,funcName:n}=e;const o=Rt(t[0],"size");if(r.settings.strict){const e="m"===n[1],t="mu"===o.value.unit;e?(t||r.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+n+" supports only mu units, not "+o.value.unit+" units"),"math"!==r.mode&&r.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+n+" works only in math mode")):t&&r.settings.reportNonstrict("mathVsTextUnits","LaTeX's "+n+" doesn't support mu units")}return{type:"kern",mode:r.mode,dimension:o.value}},htmlBuilder(e,t){return Pe.makeGlue(e.dimension,t)},mathmlBuilder(e,t){const r=P(e.dimension,t);return new ft.SpaceNode(r)}}),$e({type:"lap",names:["\\mathllap","\\mathrlap","\\mathclap"],props:{numArgs:1,allowedInText:!0},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0];return{type:"lap",mode:r.mode,alignment:n.slice(5),body:o}},htmlBuilder:(e,t)=>{let r;"clap"===e.alignment?(r=Pe.makeSpan([],[ct(e.body,t)]),r=Pe.makeSpan(["inner"],[r],t)):r=Pe.makeSpan(["inner"],[ct(e.body,t)]);const n=Pe.makeSpan(["fix"],[]);let o=Pe.makeSpan([e.alignment],[r,n],t);const s=Pe.makeSpan(["strut"]);return s.style.height=F(o.height+o.depth),o.depth&&(s.style.verticalAlign=F(-o.depth)),o.children.unshift(s),o=Pe.makeSpan(["thinbox"],[o],t),Pe.makeSpan(["mord","vbox"],[o],t)},mathmlBuilder:(e,t)=>{const r=new ft.MathNode("mpadded",[St(e.body,t)]);if("rlap"!==e.alignment){const t="llap"===e.alignment?"-1":"-0.5";r.setAttribute("lspace",t+"width")}return r.setAttribute("width","0px"),r}}),$e({type:"styling",names:["\\(","$"],props:{numArgs:0,allowedInText:!0,allowedInMath:!1},handler(e,t){let{funcName:r,parser:n}=e;const o=n.mode;n.switchMode("math");const s="\\("===r?"\\)":"$",i=n.parseExpression(!1,s);return n.expect(s),n.switchMode(o),{type:"styling",mode:n.mode,style:"text",body:i}}}),$e({type:"text",names:["\\)","\\]"],props:{numArgs:0,allowedInText:!0,allowedInMath:!1},handler(e,t){throw new n("Mismatched "+e.funcName)}});const Qr=(e,t)=>{switch(t.style.size){case w.DISPLAY.size:return e.display;case w.TEXT.size:return e.text;case w.SCRIPT.size:return e.script;case w.SCRIPTSCRIPT.size:return e.scriptscript;default:return e.text}};$e({type:"mathchoice",names:["\\mathchoice"],props:{numArgs:4,primitive:!0},handler:(e,t)=>{let{parser:r}=e;return{type:"mathchoice",mode:r.mode,display:Je(t[0]),text:Je(t[1]),script:Je(t[2]),scriptscript:Je(t[3])}},htmlBuilder:(e,t)=>{const r=Qr(e,t),n=ot(r,t,!1);return Pe.makeFragment(n)},mathmlBuilder:(e,t)=>{const r=Qr(e,t);return kt(r,t)}});const en=(e,t,r,n,o,s,i)=>{e=Pe.makeSpan([],[e]);const a=r&&l.isCharacterBox(r);let h,c,m;if(t){const e=ct(t,n.havingStyle(o.sup()),n);c={elem:e,kern:Math.max(n.fontMetrics().bigOpSpacing1,n.fontMetrics().bigOpSpacing3-e.depth)}}if(r){const e=ct(r,n.havingStyle(o.sub()),n);h={elem:e,kern:Math.max(n.fontMetrics().bigOpSpacing2,n.fontMetrics().bigOpSpacing4-e.height)}}if(c&&h){const t=n.fontMetrics().bigOpSpacing5+h.elem.height+h.elem.depth+h.kern+e.depth+i;m=Pe.makeVList({positionType:"bottom",positionData:t,children:[{type:"kern",size:n.fontMetrics().bigOpSpacing5},{type:"elem",elem:h.elem,marginLeft:F(-s)},{type:"kern",size:h.kern},{type:"elem",elem:e},{type:"kern",size:c.kern},{type:"elem",elem:c.elem,marginLeft:F(s)},{type:"kern",size:n.fontMetrics().bigOpSpacing5}]},n)}else if(h){const t=e.height-i;m=Pe.makeVList({positionType:"top",positionData:t,children:[{type:"kern",size:n.fontMetrics().bigOpSpacing5},{type:"elem",elem:h.elem,marginLeft:F(-s)},{type:"kern",size:h.kern},{type:"elem",elem:e}]},n)}else{if(!c)return e;{const t=e.depth+i;m=Pe.makeVList({positionType:"bottom",positionData:t,children:[{type:"elem",elem:e},{type:"kern",size:c.kern},{type:"elem",elem:c.elem,marginLeft:F(s)},{type:"kern",size:n.fontMetrics().bigOpSpacing5}]},n)}}const p=[m];if(h&&0!==s&&!a){const e=Pe.makeSpan(["mspace"],[],n);e.style.marginRight=F(s),p.unshift(e)}return Pe.makeSpan(["mop","op-limits"],p,n)},tn=["\\smallint"],rn=(e,t)=>{let r,n,o,s=!1;"supsub"===e.type?(r=e.sup,n=e.sub,o=Rt(e.base,"op"),s=!0):o=Rt(e,"op");const i=t.style;let a,h=!1;if(i.size===w.DISPLAY.size&&o.symbol&&!l.contains(tn,o.name)&&(h=!0),o.symbol){const e=h?"Size2-Regular":"Size1-Regular";let r="";if("\\oiint"!==o.name&&"\\oiiint"!==o.name||(r=o.name.slice(1),o.name="oiint"===r?"\\iint":"\\iiint"),a=Pe.makeSymbol(o.name,e,"math",t,["mop","op-symbol",h?"large-op":"small-op"]),r.length>0){const e=a.italic,n=Pe.staticSvg(r+"Size"+(h?"2":"1"),t);a=Pe.makeVList({positionType:"individualShift",children:[{type:"elem",elem:a,shift:0},{type:"elem",elem:n,shift:h?.08:0}]},t),o.name="\\"+r,a.classes.unshift("mop"),a.italic=e}}else if(o.body){const e=ot(o.body,t,!0);1===e.length&&e[0]instanceof K?(a=e[0],a.classes[0]="mop"):a=Pe.makeSpan(["mop"],e,t)}else{const e=[];for(let r=1;r<o.name.length;r++)e.push(Pe.mathsym(o.name[r],o.mode,t));a=Pe.makeSpan(["mop"],e,t)}let c=0,m=0;return(a instanceof K||"\\oiint"===o.name||"\\oiiint"===o.name)&&!o.suppressBaseShift&&(c=(a.height-a.depth)/2-t.fontMetrics().axisHeight,m=a.italic),s?en(a,r,n,t,i,m,c):(c&&(a.style.position="relative",a.style.top=F(c)),a)},nn=(e,t)=>{let r;if(e.symbol)r=new dt("mo",[bt(e.name,e.mode)]),l.contains(tn,e.name)&&r.setAttribute("largeop","false");else if(e.body)r=new dt("mo",vt(e.body,t));else{r=new dt("mi",[new gt(e.name.slice(1))]);const t=new dt("mo",[bt("\u2061","text")]);r=e.parentIsSupSub?new dt("mrow",[r,t]):ut([r,t])}return r},on={"\u220f":"\\prod","\u2210":"\\coprod","\u2211":"\\sum","\u22c0":"\\bigwedge","\u22c1":"\\bigvee","\u22c2":"\\bigcap","\u22c3":"\\bigcup","\u2a00":"\\bigodot","\u2a01":"\\bigoplus","\u2a02":"\\bigotimes","\u2a04":"\\biguplus","\u2a06":"\\bigsqcup"};$e({type:"op",names:["\\coprod","\\bigvee","\\bigwedge","\\biguplus","\\bigcap","\\bigcup","\\intop","\\prod","\\sum","\\bigotimes","\\bigoplus","\\bigodot","\\bigsqcup","\\smallint","\u220f","\u2210","\u2211","\u22c0","\u22c1","\u22c2","\u22c3","\u2a00","\u2a01","\u2a02","\u2a04","\u2a06"],props:{numArgs:0},handler:(e,t)=>{let{parser:r,funcName:n}=e,o=n;return 1===o.length&&(o=on[o]),{type:"op",mode:r.mode,limits:!0,parentIsSupSub:!1,symbol:!0,name:o}},htmlBuilder:rn,mathmlBuilder:nn}),$e({type:"op",names:["\\mathop"],props:{numArgs:1,primitive:!0},handler:(e,t)=>{let{parser:r}=e;const n=t[0];return{type:"op",mode:r.mode,limits:!1,parentIsSupSub:!1,symbol:!1,body:Je(n)}},htmlBuilder:rn,mathmlBuilder:nn});const sn={"\u222b":"\\int","\u222c":"\\iint","\u222d":"\\iiint","\u222e":"\\oint","\u222f":"\\oiint","\u2230":"\\oiiint"};$e({type:"op",names:["\\arcsin","\\arccos","\\arctan","\\arctg","\\arcctg","\\arg","\\ch","\\cos","\\cosec","\\cosh","\\cot","\\cotg","\\coth","\\csc","\\ctg","\\cth","\\deg","\\dim","\\exp","\\hom","\\ker","\\lg","\\ln","\\log","\\sec","\\sin","\\sinh","\\sh","\\tan","\\tanh","\\tg","\\th"],props:{numArgs:0},handler(e){let{parser:t,funcName:r}=e;return{type:"op",mode:t.mode,limits:!1,parentIsSupSub:!1,symbol:!1,name:r}},htmlBuilder:rn,mathmlBuilder:nn}),$e({type:"op",names:["\\det","\\gcd","\\inf","\\lim","\\max","\\min","\\Pr","\\sup"],props:{numArgs:0},handler(e){let{parser:t,funcName:r}=e;return{type:"op",mode:t.mode,limits:!0,parentIsSupSub:!1,symbol:!1,name:r}},htmlBuilder:rn,mathmlBuilder:nn}),$e({type:"op",names:["\\int","\\iint","\\iiint","\\oint","\\oiint","\\oiiint","\u222b","\u222c","\u222d","\u222e","\u222f","\u2230"],props:{numArgs:0},handler(e){let{parser:t,funcName:r}=e,n=r;return 1===n.length&&(n=sn[n]),{type:"op",mode:t.mode,limits:!1,parentIsSupSub:!1,symbol:!0,name:n}},htmlBuilder:rn,mathmlBuilder:nn});const an=(e,t)=>{let r,n,o,s,i=!1;if("supsub"===e.type?(r=e.sup,n=e.sub,o=Rt(e.base,"operatorname"),i=!0):o=Rt(e,"operatorname"),o.body.length>0){const e=o.body.map((e=>{const t=e.text;return"string"==typeof t?{type:"textord",mode:e.mode,text:t}:e})),r=ot(e,t.withFont("mathrm"),!0);for(let e=0;e<r.length;e++){const t=r[e];t instanceof K&&(t.text=t.text.replace(/\u2212/,"-").replace(/\u2217/,"*"))}s=Pe.makeSpan(["mop"],r,t)}else s=Pe.makeSpan(["mop"],[],t);return i?en(s,r,n,t,t.style,0,0):s};function ln(e,t,r){const n=ot(e,t,!1),o=t.sizeMultiplier/r.sizeMultiplier;for(let e=0;e<n.length;e++){const s=n[e].classes.indexOf("sizing");s<0?Array.prototype.push.apply(n[e].classes,t.sizingClasses(r)):n[e].classes[s+1]==="reset-size"+t.size&&(n[e].classes[s+1]="reset-size"+r.size),n[e].height*=o,n[e].depth*=o}return Pe.makeFragment(n)}$e({type:"operatorname",names:["\\operatorname@","\\operatornamewithlimits"],props:{numArgs:1},handler:(e,t)=>{let{parser:r,funcName:n}=e;const o=t[0];return{type:"operatorname",mode:r.mode,body:Je(o),alwaysHandleSupSub:"\\operatornamewithlimits"===n,limits:!1,parentIsSupSub:!1}},htmlBuilder:an,mathmlBuilder:(e,t)=>{let r=vt(e.body,t.withFont("mathrm")),n=!0;for(let e=0;e<r.length;e++){const t=r[e];if(t instanceof ft.SpaceNode);else if(t instanceof ft.MathNode)switch(t.type){case"mi":case"mn":case"ms":case"mspace":case"mtext":break;case"mo":{const e=t.children[0];1===t.children.length&&e instanceof ft.TextNode?e.text=e.text.replace(/\u2212/,"-").replace(/\u2217/,"*"):n=!1;break}default:n=!1}else n=!1}if(n){const e=r.map((e=>e.toText())).join("");r=[new ft.TextNode(e)]}const o=new ft.MathNode("mi",r);o.setAttribute("mathvariant","normal");const s=new ft.MathNode("mo",[bt("\u2061","text")]);return e.parentIsSupSub?new ft.MathNode("mrow",[o,s]):ft.newDocumentFragment([o,s])}}),Nr("\\operatorname","\\@ifstar\\operatornamewithlimits\\operatorname@"),Ze({type:"ordgroup",htmlBuilder(e,t){return e.semisimple?Pe.makeFragment(ot(e.body,t,!1)):Pe.makeSpan(["mord"],ot(e.body,t,!0),t)},mathmlBuilder(e,t){return kt(e.body,t,!0)}}),$e({type:"overline",names:["\\overline"],props:{numArgs:1},handler(e,t){let{parser:r}=e;const n=t[0];return{type:"overline",mode:r.mode,body:n}},htmlBuilder(e,t){const r=ct(e.body,t.havingCrampedStyle()),n=Pe.makeLineSpan("overline-line",t),o=t.fontMetrics().defaultRuleThickness,s=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:r},{type:"kern",size:3*o},{type:"elem",elem:n},{type:"kern",size:o}]},t);return Pe.makeSpan(["mord","overline"],[s],t)},mathmlBuilder(e,t){const r=new ft.MathNode("mo",[new ft.TextNode("\u203e")]);r.setAttribute("stretchy","true");const n=new ft.MathNode("mover",[St(e.body,t),r]);return n.setAttribute("accent","true"),n}}),$e({type:"phantom",names:["\\phantom"],props:{numArgs:1,allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;const n=t[0];return{type:"phantom",mode:r.mode,body:Je(n)}},htmlBuilder:(e,t)=>{const r=ot(e.body,t.withPhantom(),!1);return Pe.makeFragment(r)},mathmlBuilder:(e,t)=>{const r=vt(e.body,t);return new ft.MathNode("mphantom",r)}}),$e({type:"hphantom",names:["\\hphantom"],props:{numArgs:1,allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;const n=t[0];return{type:"hphantom",mode:r.mode,body:n}},htmlBuilder:(e,t)=>{let r=Pe.makeSpan([],[ct(e.body,t.withPhantom())]);if(r.height=0,r.depth=0,r.children)for(let e=0;e<r.children.length;e++)r.children[e].height=0,r.children[e].depth=0;return r=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:r}]},t),Pe.makeSpan(["mord"],[r],t)},mathmlBuilder:(e,t)=>{const r=vt(Je(e.body),t),n=new ft.MathNode("mphantom",r),o=new ft.MathNode("mpadded",[n]);return o.setAttribute("height","0px"),o.setAttribute("depth","0px"),o}}),$e({type:"vphantom",names:["\\vphantom"],props:{numArgs:1,allowedInText:!0},handler:(e,t)=>{let{parser:r}=e;const n=t[0];return{type:"vphantom",mode:r.mode,body:n}},htmlBuilder:(e,t)=>{const r=Pe.makeSpan(["inner"],[ct(e.body,t.withPhantom())]),n=Pe.makeSpan(["fix"],[]);return Pe.makeSpan(["mord","rlap"],[r,n],t)},mathmlBuilder:(e,t)=>{const r=vt(Je(e.body),t),n=new ft.MathNode("mphantom",r),o=new ft.MathNode("mpadded",[n]);return o.setAttribute("width","0px"),o}}),$e({type:"raisebox",names:["\\raisebox"],props:{numArgs:2,argTypes:["size","hbox"],allowedInText:!0},handler(e,t){let{parser:r}=e;const n=Rt(t[0],"size").value,o=t[1];return{type:"raisebox",mode:r.mode,dy:n,body:o}},htmlBuilder(e,t){const r=ct(e.body,t),n=P(e.dy,t);return Pe.makeVList({positionType:"shift",positionData:-n,children:[{type:"elem",elem:r}]},t)},mathmlBuilder(e,t){const r=new ft.MathNode("mpadded",[St(e.body,t)]),n=e.dy.number+e.dy.unit;return r.setAttribute("voffset",n),r}}),$e({type:"internal",names:["\\relax"],props:{numArgs:0,allowedInText:!0,allowedInArgument:!0},handler(e){let{parser:t}=e;return{type:"internal",mode:t.mode}}}),$e({type:"rule",names:["\\rule"],props:{numArgs:2,numOptionalArgs:1,allowedInText:!0,allowedInMath:!0,argTypes:["size","size","size"]},handler(e,t,r){let{parser:n}=e;const o=r[0],s=Rt(t[0],"size"),i=Rt(t[1],"size");return{type:"rule",mode:n.mode,shift:o&&Rt(o,"size").value,width:s.value,height:i.value}},htmlBuilder(e,t){const r=Pe.makeSpan(["mord","rule"],[],t),n=P(e.width,t),o=P(e.height,t),s=e.shift?P(e.shift,t):0;return r.style.borderRightWidth=F(n),r.style.borderTopWidth=F(o),r.style.bottom=F(s),r.width=n,r.height=o+s,r.depth=-s,r.maxFontSize=1.125*o*t.sizeMultiplier,r},mathmlBuilder(e,t){const r=P(e.width,t),n=P(e.height,t),o=e.shift?P(e.shift,t):0,s=t.color&&t.getColor()||"black",i=new ft.MathNode("mspace");i.setAttribute("mathbackground",s),i.setAttribute("width",F(r)),i.setAttribute("height",F(n));const a=new ft.MathNode("mpadded",[i]);return o>=0?a.setAttribute("height",F(o)):(a.setAttribute("height",F(o)),a.setAttribute("depth",F(-o))),a.setAttribute("voffset",F(o)),a}});const hn=["\\tiny","\\sixptsize","\\scriptsize","\\footnotesize","\\small","\\normalsize","\\large","\\Large","\\LARGE","\\huge","\\Huge"];$e({type:"sizing",names:hn,props:{numArgs:0,allowedInText:!0},handler:(e,t)=>{let{breakOnTokenText:r,funcName:n,parser:o}=e;const s=o.parseExpression(!1,r);return{type:"sizing",mode:o.mode,size:hn.indexOf(n)+1,body:s}},htmlBuilder:(e,t)=>{const r=t.havingSize(e.size);return ln(e.body,r,t)},mathmlBuilder:(e,t)=>{const r=t.havingSize(e.size),n=vt(e.body,r),o=new ft.MathNode("mstyle",n);return o.setAttribute("mathsize",F(r.sizeMultiplier)),o}}),$e({type:"smash",names:["\\smash"],props:{numArgs:1,numOptionalArgs:1,allowedInText:!0},handler:(e,t,r)=>{let{parser:n}=e,o=!1,s=!1;const i=r[0]&&Rt(r[0],"ordgroup");if(i){let e="";for(let t=0;t<i.body.length;++t){if(e=i.body[t].text,"t"===e)o=!0;else{if("b"!==e){o=!1,s=!1;break}s=!0}}}else o=!0,s=!0;const a=t[0];return{type:"smash",mode:n.mode,body:a,smashHeight:o,smashDepth:s}},htmlBuilder:(e,t)=>{const r=Pe.makeSpan([],[ct(e.body,t)]);if(!e.smashHeight&&!e.smashDepth)return r;if(e.smashHeight&&(r.height=0,r.children))for(let e=0;e<r.children.length;e++)r.children[e].height=0;if(e.smashDepth&&(r.depth=0,r.children))for(let e=0;e<r.children.length;e++)r.children[e].depth=0;const n=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:r}]},t);return Pe.makeSpan(["mord"],[n],t)},mathmlBuilder:(e,t)=>{const r=new ft.MathNode("mpadded",[St(e.body,t)]);return e.smashHeight&&r.setAttribute("height","0px"),e.smashDepth&&r.setAttribute("depth","0px"),r}}),$e({type:"sqrt",names:["\\sqrt"],props:{numArgs:1,numOptionalArgs:1},handler(e,t,r){let{parser:n}=e;const o=r[0],s=t[0];return{type:"sqrt",mode:n.mode,body:s,index:o}},htmlBuilder(e,t){let r=ct(e.body,t.havingCrampedStyle());0===r.height&&(r.height=t.fontMetrics().xHeight),r=Pe.wrapFragment(r,t);const n=t.fontMetrics().defaultRuleThickness;let o=n;t.style.id<w.TEXT.id&&(o=t.fontMetrics().xHeight);let s=n+o/4;const i=r.height+r.depth+s+n,{span:a,ruleWidth:l,advanceWidth:h}=wr.sqrtImage(i,t),c=a.height-l;c>r.height+r.depth+s&&(s=(s+c-r.height-r.depth)/2);const m=a.height-r.height-s-l;r.style.paddingLeft=F(h);const p=Pe.makeVList({positionType:"firstBaseline",children:[{type:"elem",elem:r,wrapperClasses:["svg-align"]},{type:"kern",size:-(r.height+m)},{type:"elem",elem:a},{type:"kern",size:l}]},t);if(e.index){const r=t.havingStyle(w.SCRIPTSCRIPT),n=ct(e.index,r,t),o=.6*(p.height-p.depth),s=Pe.makeVList({positionType:"shift",positionData:-o,children:[{type:"elem",elem:n}]},t),i=Pe.makeSpan(["root"],[s]);return Pe.makeSpan(["mord","sqrt"],[i,p],t)}return Pe.makeSpan(["mord","sqrt"],[p],t)},mathmlBuilder(e,t){const{body:r,index:n}=e;return n?new ft.MathNode("mroot",[St(r,t),St(n,t)]):new ft.MathNode("msqrt",[St(r,t)])}});const cn={display:w.DISPLAY,text:w.TEXT,script:w.SCRIPT,scriptscript:w.SCRIPTSCRIPT};$e({type:"styling",names:["\\displaystyle","\\textstyle","\\scriptstyle","\\scriptscriptstyle"],props:{numArgs:0,allowedInText:!0,primitive:!0},handler(e,t){let{breakOnTokenText:r,funcName:n,parser:o}=e;const s=o.parseExpression(!0,r),i=n.slice(1,n.length-5);return{type:"styling",mode:o.mode,style:i,body:s}},htmlBuilder(e,t){const r=cn[e.style],n=t.havingStyle(r).withFont("");return ln(e.body,n,t)},mathmlBuilder(e,t){const r=cn[e.style],n=t.havingStyle(r),o=vt(e.body,n),s=new ft.MathNode("mstyle",o),i={display:["0","true"],text:["0","false"],script:["1","false"],scriptscript:["2","false"]}[e.style];return s.setAttribute("scriptlevel",i[0]),s.setAttribute("displaystyle",i[1]),s}});Ze({type:"supsub",htmlBuilder(e,t){const r=function(e,t){const r=e.base;if(r)return"op"===r.type?r.limits&&(t.style.size===w.DISPLAY.size||r.alwaysHandleSupSub)?rn:null:"operatorname"===r.type?r.alwaysHandleSupSub&&(t.style.size===w.DISPLAY.size||r.limits)?an:null:"accent"===r.type?l.isCharacterBox(r.base)?Et:null:"horizBrace"===r.type&&!e.sub===r.isOver?Kr:null;return null}(e,t);if(r)return r(e,t);const{base:n,sup:o,sub:s}=e,i=ct(n,t);let a,h;const c=t.fontMetrics();let m=0,p=0;const u=n&&l.isCharacterBox(n);if(o){const e=t.havingStyle(t.style.sup());a=ct(o,e,t),u||(m=i.height-e.fontMetrics().supDrop*e.sizeMultiplier/t.sizeMultiplier)}if(s){const e=t.havingStyle(t.style.sub());h=ct(s,e,t),u||(p=i.depth+e.fontMetrics().subDrop*e.sizeMultiplier/t.sizeMultiplier)}let d;d=t.style===w.DISPLAY?c.sup1:t.style.cramped?c.sup3:c.sup2;const g=t.sizeMultiplier,f=F(.5/c.ptPerEm/g);let b,y=null;if(h){const t=e.base&&"op"===e.base.type&&e.base.name&&("\\oiint"===e.base.name||"\\oiiint"===e.base.name);(i instanceof K||t)&&(y=F(-i.italic))}if(a&&h){m=Math.max(m,d,a.depth+.25*c.xHeight),p=Math.max(p,c.sub2);const e=4*c.defaultRuleThickness;if(m-a.depth-(h.height-p)<e){p=e-(m-a.depth)+h.height;const t=.8*c.xHeight-(m-a.depth);t>0&&(m+=t,p-=t)}const r=[{type:"elem",elem:h,shift:p,marginRight:f,marginLeft:y},{type:"elem",elem:a,shift:-m,marginRight:f}];b=Pe.makeVList({positionType:"individualShift",children:r},t)}else if(h){p=Math.max(p,c.sub1,h.height-.8*c.xHeight);const e=[{type:"elem",elem:h,marginLeft:y,marginRight:f}];b=Pe.makeVList({positionType:"shift",positionData:p,children:e},t)}else{if(!a)throw new Error("supsub must have either sup or sub.");m=Math.max(m,d,a.depth+.25*c.xHeight),b=Pe.makeVList({positionType:"shift",positionData:-m,children:[{type:"elem",elem:a,marginRight:f}]},t)}const x=lt(i,"right")||"mord";return Pe.makeSpan([x],[i,Pe.makeSpan(["msupsub"],[b])],t)},mathmlBuilder(e,t){let r,n,o=!1;e.base&&"horizBrace"===e.base.type&&(n=!!e.sup,n===e.base.isOver&&(o=!0,r=e.base.isOver)),!e.base||"op"!==e.base.type&&"operatorname"!==e.base.type||(e.base.parentIsSupSub=!0);const s=[St(e.base,t)];let i;if(e.sub&&s.push(St(e.sub,t)),e.sup&&s.push(St(e.sup,t)),o)i=r?"mover":"munder";else if(e.sub)if(e.sup){const r=e.base;i=r&&"op"===r.type&&r.limits&&t.style===w.DISPLAY||r&&"operatorname"===r.type&&r.alwaysHandleSupSub&&(t.style===w.DISPLAY||r.limits)?"munderover":"msubsup"}else{const r=e.base;i=r&&"op"===r.type&&r.limits&&(t.style===w.DISPLAY||r.alwaysHandleSupSub)||r&&"operatorname"===r.type&&r.alwaysHandleSupSub&&(r.limits||t.style===w.DISPLAY)?"munder":"msub"}else{const r=e.base;i=r&&"op"===r.type&&r.limits&&(t.style===w.DISPLAY||r.alwaysHandleSupSub)||r&&"operatorname"===r.type&&r.alwaysHandleSupSub&&(r.limits||t.style===w.DISPLAY)?"mover":"msup"}return new ft.MathNode(i,s)}}),Ze({type:"atom",htmlBuilder(e,t){return Pe.mathsym(e.text,e.mode,t,["m"+e.family])},mathmlBuilder(e,t){const r=new ft.MathNode("mo",[bt(e.text,e.mode)]);if("bin"===e.family){const n=xt(e,t);"bold-italic"===n&&r.setAttribute("mathvariant",n)}else"punct"===e.family?r.setAttribute("separator","true"):"open"!==e.family&&"close"!==e.family||r.setAttribute("stretchy","false");return r}});const mn={mi:"italic",mn:"normal",mtext:"normal"};Ze({type:"mathord",htmlBuilder(e,t){return Pe.makeOrd(e,t,"mathord")},mathmlBuilder(e,t){const r=new ft.MathNode("mi",[bt(e.text,e.mode,t)]),n=xt(e,t)||"italic";return n!==mn[r.type]&&r.setAttribute("mathvariant",n),r}}),Ze({type:"textord",htmlBuilder(e,t){return Pe.makeOrd(e,t,"textord")},mathmlBuilder(e,t){const r=bt(e.text,e.mode,t),n=xt(e,t)||"normal";let o;return o="text"===e.mode?new ft.MathNode("mtext",[r]):/[0-9]/.test(e.text)?new ft.MathNode("mn",[r]):"\\prime"===e.text?new ft.MathNode("mo",[r]):new ft.MathNode("mi",[r]),n!==mn[o.type]&&o.setAttribute("mathvariant",n),o}});const pn={"\\nobreak":"nobreak","\\allowbreak":"allowbreak"},un={" ":{},"\\ ":{},"~":{className:"nobreak"},"\\space":{},"\\nobreakspace":{className:"nobreak"}};Ze({type:"spacing",htmlBuilder(e,t){if(un.hasOwnProperty(e.text)){const r=un[e.text].className||"";if("text"===e.mode){const n=Pe.makeOrd(e,t,"textord");return n.classes.push(r),n}return Pe.makeSpan(["mspace",r],[Pe.mathsym(e.text,e.mode,t)],t)}if(pn.hasOwnProperty(e.text))return Pe.makeSpan(["mspace",pn[e.text]],[],t);throw new n('Unknown type of space "'+e.text+'"')},mathmlBuilder(e,t){let r;if(!un.hasOwnProperty(e.text)){if(pn.hasOwnProperty(e.text))return new ft.MathNode("mspace");throw new n('Unknown type of space "'+e.text+'"')}return r=new ft.MathNode("mtext",[new ft.TextNode("\xa0")]),r}});const dn=()=>{const e=new ft.MathNode("mtd",[]);return e.setAttribute("width","50%"),e};Ze({type:"tag",mathmlBuilder(e,t){const r=new ft.MathNode("mtable",[new ft.MathNode("mtr",[dn(),new ft.MathNode("mtd",[kt(e.body,t)]),dn(),new ft.MathNode("mtd",[kt(e.tag,t)])])]);return r.setAttribute("width","100%"),r}});const gn={"\\text":void 0,"\\textrm":"textrm","\\textsf":"textsf","\\texttt":"texttt","\\textnormal":"textrm"},fn={"\\textbf":"textbf","\\textmd":"textmd"},bn={"\\textit":"textit","\\textup":"textup"},yn=(e,t)=>{const r=e.font;return r?gn[r]?t.withTextFontFamily(gn[r]):fn[r]?t.withTextFontWeight(fn[r]):"\\emph"===r?"textit"===t.fontShape?t.withTextFontShape("textup"):t.withTextFontShape("textit"):t.withTextFontShape(bn[r]):t};$e({type:"text",names:["\\text","\\textrm","\\textsf","\\texttt","\\textnormal","\\textbf","\\textmd","\\textit","\\textup","\\emph"],props:{numArgs:1,argTypes:["text"],allowedInArgument:!0,allowedInText:!0},handler(e,t){let{parser:r,funcName:n}=e;const o=t[0];return{type:"text",mode:r.mode,body:Je(o),font:n}},htmlBuilder(e,t){const r=yn(e,t),n=ot(e.body,r,!0);return Pe.makeSpan(["mord","text"],n,r)},mathmlBuilder(e,t){const r=yn(e,t);return kt(e.body,r)}}),$e({type:"underline",names:["\\underline"],props:{numArgs:1,allowedInText:!0},handler(e,t){let{parser:r}=e;return{type:"underline",mode:r.mode,body:t[0]}},htmlBuilder(e,t){const r=ct(e.body,t),n=Pe.makeLineSpan("underline-line",t),o=t.fontMetrics().defaultRuleThickness,s=Pe.makeVList({positionType:"top",positionData:r.height,children:[{type:"kern",size:o},{type:"elem",elem:n},{type:"kern",size:3*o},{type:"elem",elem:r}]},t);return Pe.makeSpan(["mord","underline"],[s],t)},mathmlBuilder(e,t){const r=new ft.MathNode("mo",[new ft.TextNode("\u203e")]);r.setAttribute("stretchy","true");const n=new ft.MathNode("munder",[St(e.body,t),r]);return n.setAttribute("accentunder","true"),n}}),$e({type:"vcenter",names:["\\vcenter"],props:{numArgs:1,argTypes:["original"],allowedInText:!1},handler(e,t){let{parser:r}=e;return{type:"vcenter",mode:r.mode,body:t[0]}},htmlBuilder(e,t){const r=ct(e.body,t),n=t.fontMetrics().axisHeight,o=.5*(r.height-n-(r.depth+n));return Pe.makeVList({positionType:"shift",positionData:o,children:[{type:"elem",elem:r}]},t)},mathmlBuilder(e,t){return new ft.MathNode("mpadded",[St(e.body,t)],["vcenter"])}}),$e({type:"verb",names:["\\verb"],props:{numArgs:0,allowedInText:!0},handler(e,t,r){throw new n("\\verb ended by end of line instead of matching delimiter")},htmlBuilder(e,t){const r=xn(e),n=[],o=t.havingStyle(t.style.text());for(let t=0;t<r.length;t++){let s=r[t];"~"===s&&(s="\\textasciitilde"),n.push(Pe.makeSymbol(s,"Typewriter-Regular",e.mode,o,["mord","texttt"]))}return Pe.makeSpan(["mord","text"].concat(o.sizingClasses(t)),Pe.tryCombineChars(n),o)},mathmlBuilder(e,t){const r=new ft.TextNode(xn(e)),n=new ft.MathNode("mtext",[r]);return n.setAttribute("mathvariant","monospace"),n}});const xn=e=>e.body.replace(/ /g,e.star?"\u2423":"\xa0");var wn=We;const vn="[ \r\n\t]",kn="(\\\\[a-zA-Z@]+)"+vn+"*",Sn="[\u0300-\u036f]",Mn=new RegExp(Sn+"+$"),zn="("+vn+"+)|\\\\(\n|[ \r\t]+\n?)[ \r\t]*|([!-\\[\\]-\u2027\u202a-\ud7ff\uf900-\uffff]"+Sn+"*|[\ud800-\udbff][\udc00-\udfff]"+Sn+"*|\\\\verb\\*([^]).*?\\4|\\\\verb([^*a-zA-Z]).*?\\5|"+kn+"|\\\\[^\ud800-\udfff])";class An{constructor(e,t){this.input=void 0,this.settings=void 0,this.tokenRegex=void 0,this.catcodes=void 0,this.input=e,this.settings=t,this.tokenRegex=new RegExp(zn,"g"),this.catcodes={"%":14,"~":13}}setCatcode(e,t){this.catcodes[e]=t}lex(){const e=this.input,t=this.tokenRegex.lastIndex;if(t===e.length)return new Ir("EOF",new qr(this,t,t));const r=this.tokenRegex.exec(e);if(null===r||r.index!==t)throw new n("Unexpected character: '"+e[t]+"'",new Ir(e[t],new qr(this,t,t+1)));const o=r[6]||r[3]||(r[2]?"\\ ":" ");if(14===this.catcodes[o]){const t=e.indexOf("\n",this.tokenRegex.lastIndex);return-1===t?(this.tokenRegex.lastIndex=e.length,this.settings.reportNonstrict("commentAtEnd","% comment has no terminating newline; LaTeX would fail because of commenting the end of math mode (e.g. $)")):this.tokenRegex.lastIndex=t+1,this.lex()}return new Ir(o,new qr(this,t,this.tokenRegex.lastIndex))}}class Tn{constructor(e,t){void 0===e&&(e={}),void 0===t&&(t={}),this.current=void 0,this.builtins=void 0,this.undefStack=void 0,this.current=t,this.builtins=e,this.undefStack=[]}beginGroup(){this.undefStack.push({})}endGroup(){if(0===this.undefStack.length)throw new n("Unbalanced namespace destruction: attempt to pop global namespace; please report this as a bug");const e=this.undefStack.pop();for(const t in e)e.hasOwnProperty(t)&&(null==e[t]?delete this.current[t]:this.current[t]=e[t])}endGroups(){for(;this.undefStack.length>0;)this.endGroup()}has(e){return this.current.hasOwnProperty(e)||this.builtins.hasOwnProperty(e)}get(e){return this.current.hasOwnProperty(e)?this.current[e]:this.builtins[e]}set(e,t,r){if(void 0===r&&(r=!1),r){for(let t=0;t<this.undefStack.length;t++)delete this.undefStack[t][e];this.undefStack.length>0&&(this.undefStack[this.undefStack.length-1][e]=t)}else{const t=this.undefStack[this.undefStack.length-1];t&&!t.hasOwnProperty(e)&&(t[e]=this.current[e])}null==t?delete this.current[e]:this.current[e]=t}}var Bn=Cr;Nr("\\noexpand",(function(e){const t=e.popToken();return e.isExpandable(t.text)&&(t.noexpand=!0,t.treatAsRelax=!0),{tokens:[t],numArgs:0}})),Nr("\\expandafter",(function(e){const t=e.popToken();return e.expandOnce(!0),{tokens:[t],numArgs:0}})),Nr("\\@firstoftwo",(function(e){return{tokens:e.consumeArgs(2)[0],numArgs:0}})),Nr("\\@secondoftwo",(function(e){return{tokens:e.consumeArgs(2)[1],numArgs:0}})),Nr("\\@ifnextchar",(function(e){const t=e.consumeArgs(3);e.consumeSpaces();const r=e.future();return 1===t[0].length&&t[0][0].text===r.text?{tokens:t[1],numArgs:0}:{tokens:t[2],numArgs:0}})),Nr("\\@ifstar","\\@ifnextchar *{\\@firstoftwo{#1}}"),Nr("\\TextOrMath",(function(e){const t=e.consumeArgs(2);return"text"===e.mode?{tokens:t[0],numArgs:0}:{tokens:t[1],numArgs:0}}));const Cn={0:0,1:1,2:2,3:3,4:4,5:5,6:6,7:7,8:8,9:9,a:10,A:10,b:11,B:11,c:12,C:12,d:13,D:13,e:14,E:14,f:15,F:15};Nr("\\char",(function(e){let t,r=e.popToken(),o="";if("'"===r.text)t=8,r=e.popToken();else if('"'===r.text)t=16,r=e.popToken();else if("`"===r.text)if(r=e.popToken(),"\\"===r.text[0])o=r.text.charCodeAt(1);else{if("EOF"===r.text)throw new n("\\char` missing argument");o=r.text.charCodeAt(0)}else t=10;if(t){if(o=Cn[r.text],null==o||o>=t)throw new n("Invalid base-"+t+" digit "+r.text);let s;for(;null!=(s=Cn[e.future().text])&&s<t;)o*=t,o+=s,e.popToken()}return"\\@char{"+o+"}"}));const Nn=(e,t,r,o)=>{let s=e.consumeArg().tokens;if(1!==s.length)throw new n("\\newcommand's first argument must be a macro name");const i=s[0].text,a=e.isDefined(i);if(a&&!t)throw new n("\\newcommand{"+i+"} attempting to redefine "+i+"; use \\renewcommand");if(!a&&!r)throw new n("\\renewcommand{"+i+"} when command "+i+" does not yet exist; use \\newcommand");let l=0;if(s=e.consumeArg().tokens,1===s.length&&"["===s[0].text){let t="",r=e.expandNextToken();for(;"]"!==r.text&&"EOF"!==r.text;)t+=r.text,r=e.expandNextToken();if(!t.match(/^\s*[0-9]+\s*$/))throw new n("Invalid number of arguments: "+t);l=parseInt(t),s=e.consumeArg().tokens}return a&&o||e.macros.set(i,{tokens:s,numArgs:l}),""};Nr("\\newcommand",(e=>Nn(e,!1,!0,!1))),Nr("\\renewcommand",(e=>Nn(e,!0,!1,!1))),Nr("\\providecommand",(e=>Nn(e,!0,!0,!0))),Nr("\\message",(e=>{const t=e.consumeArgs(1)[0];return console.log(t.reverse().map((e=>e.text)).join("")),""})),Nr("\\errmessage",(e=>{const t=e.consumeArgs(1)[0];return console.error(t.reverse().map((e=>e.text)).join("")),""})),Nr("\\show",(e=>{const t=e.popToken(),r=t.text;return console.log(t,e.macros.get(r),wn[r],se.math[r],se.text[r]),""})),Nr("\\bgroup","{"),Nr("\\egroup","}"),Nr("~","\\nobreakspace"),Nr("\\lq","`"),Nr("\\rq","'"),Nr("\\aa","\\r a"),Nr("\\AA","\\r A"),Nr("\\textcopyright","\\html@mathml{\\textcircled{c}}{\\char`\xa9}"),Nr("\\copyright","\\TextOrMath{\\textcopyright}{\\text{\\textcopyright}}"),Nr("\\textregistered","\\html@mathml{\\textcircled{\\scriptsize R}}{\\char`\xae}"),Nr("\u212c","\\mathscr{B}"),Nr("\u2130","\\mathscr{E}"),Nr("\u2131","\\mathscr{F}"),Nr("\u210b","\\mathscr{H}"),Nr("\u2110","\\mathscr{I}"),Nr("\u2112","\\mathscr{L}"),Nr("\u2133","\\mathscr{M}"),Nr("\u211b","\\mathscr{R}"),Nr("\u212d","\\mathfrak{C}"),Nr("\u210c","\\mathfrak{H}"),Nr("\u2128","\\mathfrak{Z}"),Nr("\\Bbbk","\\Bbb{k}"),Nr("\xb7","\\cdotp"),Nr("\\llap","\\mathllap{\\textrm{#1}}"),Nr("\\rlap","\\mathrlap{\\textrm{#1}}"),Nr("\\clap","\\mathclap{\\textrm{#1}}"),Nr("\\mathstrut","\\vphantom{(}"),Nr("\\underbar","\\underline{\\text{#1}}"),Nr("\\not",'\\html@mathml{\\mathrel{\\mathrlap\\@not}}{\\char"338}'),Nr("\\neq","\\html@mathml{\\mathrel{\\not=}}{\\mathrel{\\char`\u2260}}"),Nr("\\ne","\\neq"),Nr("\u2260","\\neq"),Nr("\\notin","\\html@mathml{\\mathrel{{\\in}\\mathllap{/\\mskip1mu}}}{\\mathrel{\\char`\u2209}}"),Nr("\u2209","\\notin"),Nr("\u2258","\\html@mathml{\\mathrel{=\\kern{-1em}\\raisebox{0.4em}{$\\scriptsize\\frown$}}}{\\mathrel{\\char`\u2258}}"),Nr("\u2259","\\html@mathml{\\stackrel{\\tiny\\wedge}{=}}{\\mathrel{\\char`\u2258}}"),Nr("\u225a","\\html@mathml{\\stackrel{\\tiny\\vee}{=}}{\\mathrel{\\char`\u225a}}"),Nr("\u225b","\\html@mathml{\\stackrel{\\scriptsize\\star}{=}}{\\mathrel{\\char`\u225b}}"),Nr("\u225d","\\html@mathml{\\stackrel{\\tiny\\mathrm{def}}{=}}{\\mathrel{\\char`\u225d}}"),Nr("\u225e","\\html@mathml{\\stackrel{\\tiny\\mathrm{m}}{=}}{\\mathrel{\\char`\u225e}}"),Nr("\u225f","\\html@mathml{\\stackrel{\\tiny?}{=}}{\\mathrel{\\char`\u225f}}"),Nr("\u27c2","\\perp"),Nr("\u203c","\\mathclose{!\\mkern-0.8mu!}"),Nr("\u220c","\\notni"),Nr("\u231c","\\ulcorner"),Nr("\u231d","\\urcorner"),Nr("\u231e","\\llcorner"),Nr("\u231f","\\lrcorner"),Nr("\xa9","\\copyright"),Nr("\xae","\\textregistered"),Nr("\ufe0f","\\textregistered"),Nr("\\ulcorner",'\\html@mathml{\\@ulcorner}{\\mathop{\\char"231c}}'),Nr("\\urcorner",'\\html@mathml{\\@urcorner}{\\mathop{\\char"231d}}'),Nr("\\llcorner",'\\html@mathml{\\@llcorner}{\\mathop{\\char"231e}}'),Nr("\\lrcorner",'\\html@mathml{\\@lrcorner}{\\mathop{\\char"231f}}'),Nr("\\vdots","{\\varvdots\\rule{0pt}{15pt}}"),Nr("\u22ee","\\vdots"),Nr("\\varGamma","\\mathit{\\Gamma}"),Nr("\\varDelta","\\mathit{\\Delta}"),Nr("\\varTheta","\\mathit{\\Theta}"),Nr("\\varLambda","\\mathit{\\Lambda}"),Nr("\\varXi","\\mathit{\\Xi}"),Nr("\\varPi","\\mathit{\\Pi}"),Nr("\\varSigma","\\mathit{\\Sigma}"),Nr("\\varUpsilon","\\mathit{\\Upsilon}"),Nr("\\varPhi","\\mathit{\\Phi}"),Nr("\\varPsi","\\mathit{\\Psi}"),Nr("\\varOmega","\\mathit{\\Omega}"),Nr("\\substack","\\begin{subarray}{c}#1\\end{subarray}"),Nr("\\colon","\\nobreak\\mskip2mu\\mathpunct{}\\mathchoice{\\mkern-3mu}{\\mkern-3mu}{}{}{:}\\mskip6mu\\relax"),Nr("\\boxed","\\fbox{$\\displaystyle{#1}$}"),Nr("\\iff","\\DOTSB\\;\\Longleftrightarrow\\;"),Nr("\\implies","\\DOTSB\\;\\Longrightarrow\\;"),Nr("\\impliedby","\\DOTSB\\;\\Longleftarrow\\;"),Nr("\\dddot","{\\overset{\\raisebox{-0.1ex}{\\normalsize ...}}{#1}}"),Nr("\\ddddot","{\\overset{\\raisebox{-0.1ex}{\\normalsize ....}}{#1}}");const qn={",":"\\dotsc","\\not":"\\dotsb","+":"\\dotsb","=":"\\dotsb","<":"\\dotsb",">":"\\dotsb","-":"\\dotsb","*":"\\dotsb",":":"\\dotsb","\\DOTSB":"\\dotsb","\\coprod":"\\dotsb","\\bigvee":"\\dotsb","\\bigwedge":"\\dotsb","\\biguplus":"\\dotsb","\\bigcap":"\\dotsb","\\bigcup":"\\dotsb","\\prod":"\\dotsb","\\sum":"\\dotsb","\\bigotimes":"\\dotsb","\\bigoplus":"\\dotsb","\\bigodot":"\\dotsb","\\bigsqcup":"\\dotsb","\\And":"\\dotsb","\\longrightarrow":"\\dotsb","\\Longrightarrow":"\\dotsb","\\longleftarrow":"\\dotsb","\\Longleftarrow":"\\dotsb","\\longleftrightarrow":"\\dotsb","\\Longleftrightarrow":"\\dotsb","\\mapsto":"\\dotsb","\\longmapsto":"\\dotsb","\\hookrightarrow":"\\dotsb","\\doteq":"\\dotsb","\\mathbin":"\\dotsb","\\mathrel":"\\dotsb","\\relbar":"\\dotsb","\\Relbar":"\\dotsb","\\xrightarrow":"\\dotsb","\\xleftarrow":"\\dotsb","\\DOTSI":"\\dotsi","\\int":"\\dotsi","\\oint":"\\dotsi","\\iint":"\\dotsi","\\iiint":"\\dotsi","\\iiiint":"\\dotsi","\\idotsint":"\\dotsi","\\DOTSX":"\\dotsx"};Nr("\\dots",(function(e){let t="\\dotso";const r=e.expandAfterFuture().text;return r in qn?t=qn[r]:("\\not"===r.slice(0,4)||r in se.math&&l.contains(["bin","rel"],se.math[r].group))&&(t="\\dotsb"),t}));const In={")":!0,"]":!0,"\\rbrack":!0,"\\}":!0,"\\rbrace":!0,"\\rangle":!0,"\\rceil":!0,"\\rfloor":!0,"\\rgroup":!0,"\\rmoustache":!0,"\\right":!0,"\\bigr":!0,"\\biggr":!0,"\\Bigr":!0,"\\Biggr":!0,$:!0,";":!0,".":!0,",":!0};Nr("\\dotso",(function(e){return e.future().text in In?"\\ldots\\,":"\\ldots"})),Nr("\\dotsc",(function(e){const t=e.future().text;return t in In&&","!==t?"\\ldots\\,":"\\ldots"})),Nr("\\cdots",(function(e){return e.future().text in In?"\\@cdots\\,":"\\@cdots"})),Nr("\\dotsb","\\cdots"),Nr("\\dotsm","\\cdots"),Nr("\\dotsi","\\!\\cdots"),Nr("\\dotsx","\\ldots\\,"),Nr("\\DOTSI","\\relax"),Nr("\\DOTSB","\\relax"),Nr("\\DOTSX","\\relax"),Nr("\\tmspace","\\TextOrMath{\\kern#1#3}{\\mskip#1#2}\\relax"),Nr("\\,","\\tmspace+{3mu}{.1667em}"),Nr("\\thinspace","\\,"),Nr("\\>","\\mskip{4mu}"),Nr("\\:","\\tmspace+{4mu}{.2222em}"),Nr("\\medspace","\\:"),Nr("\\;","\\tmspace+{5mu}{.2777em}"),Nr("\\thickspace","\\;"),Nr("\\!","\\tmspace-{3mu}{.1667em}"),Nr("\\negthinspace","\\!"),Nr("\\negmedspace","\\tmspace-{4mu}{.2222em}"),Nr("\\negthickspace","\\tmspace-{5mu}{.277em}"),Nr("\\enspace","\\kern.5em "),Nr("\\enskip","\\hskip.5em\\relax"),Nr("\\quad","\\hskip1em\\relax"),Nr("\\qquad","\\hskip2em\\relax"),Nr("\\tag","\\@ifstar\\tag@literal\\tag@paren"),Nr("\\tag@paren","\\tag@literal{({#1})}"),Nr("\\tag@literal",(e=>{if(e.macros.get("\\df@tag"))throw new n("Multiple \\tag");return"\\gdef\\df@tag{\\text{#1}}"})),Nr("\\bmod","\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}\\mathbin{\\rm mod}\\mathchoice{\\mskip1mu}{\\mskip1mu}{\\mskip5mu}{\\mskip5mu}"),Nr("\\pod","\\allowbreak\\mathchoice{\\mkern18mu}{\\mkern8mu}{\\mkern8mu}{\\mkern8mu}(#1)"),Nr("\\pmod","\\pod{{\\rm mod}\\mkern6mu#1}"),Nr("\\mod","\\allowbreak\\mathchoice{\\mkern18mu}{\\mkern12mu}{\\mkern12mu}{\\mkern12mu}{\\rm mod}\\,\\,#1"),Nr("\\newline","\\\\\\relax"),Nr("\\TeX","\\textrm{\\html@mathml{T\\kern-.1667em\\raisebox{-.5ex}{E}\\kern-.125emX}{TeX}}");const Rn=F(T["Main-Regular"]["T".charCodeAt(0)][1]-.7*T["Main-Regular"]["A".charCodeAt(0)][1]);Nr("\\LaTeX","\\textrm{\\html@mathml{L\\kern-.36em\\raisebox{"+Rn+"}{\\scriptstyle A}\\kern-.15em\\TeX}{LaTeX}}"),Nr("\\KaTeX","\\textrm{\\html@mathml{K\\kern-.17em\\raisebox{"+Rn+"}{\\scriptstyle A}\\kern-.15em\\TeX}{KaTeX}}"),Nr("\\hspace","\\@ifstar\\@hspacer\\@hspace"),Nr("\\@hspace","\\hskip #1\\relax"),Nr("\\@hspacer","\\rule{0pt}{0pt}\\hskip #1\\relax"),Nr("\\ordinarycolon",":"),Nr("\\vcentcolon","\\mathrel{\\mathop\\ordinarycolon}"),Nr("\\dblcolon",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-.9mu}\\vcentcolon}}{\\mathop{\\char"2237}}'),Nr("\\coloneqq",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}=}}{\\mathop{\\char"2254}}'),Nr("\\Coloneqq",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}=}}{\\mathop{\\char"2237\\char"3d}}'),Nr("\\coloneq",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}}{\\mathop{\\char"3a\\char"2212}}'),Nr("\\Coloneq",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\mathrel{-}}}{\\mathop{\\char"2237\\char"2212}}'),Nr("\\eqqcolon",'\\html@mathml{\\mathrel{=\\mathrel{\\mkern-1.2mu}\\vcentcolon}}{\\mathop{\\char"2255}}'),Nr("\\Eqqcolon",'\\html@mathml{\\mathrel{=\\mathrel{\\mkern-1.2mu}\\dblcolon}}{\\mathop{\\char"3d\\char"2237}}'),Nr("\\eqcolon",'\\html@mathml{\\mathrel{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\vcentcolon}}{\\mathop{\\char"2239}}'),Nr("\\Eqcolon",'\\html@mathml{\\mathrel{\\mathrel{-}\\mathrel{\\mkern-1.2mu}\\dblcolon}}{\\mathop{\\char"2212\\char"2237}}'),Nr("\\colonapprox",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\approx}}{\\mathop{\\char"3a\\char"2248}}'),Nr("\\Colonapprox",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\approx}}{\\mathop{\\char"2237\\char"2248}}'),Nr("\\colonsim",'\\html@mathml{\\mathrel{\\vcentcolon\\mathrel{\\mkern-1.2mu}\\sim}}{\\mathop{\\char"3a\\char"223c}}'),Nr("\\Colonsim",'\\html@mathml{\\mathrel{\\dblcolon\\mathrel{\\mkern-1.2mu}\\sim}}{\\mathop{\\char"2237\\char"223c}}'),Nr("\u2237","\\dblcolon"),Nr("\u2239","\\eqcolon"),Nr("\u2254","\\coloneqq"),Nr("\u2255","\\eqqcolon"),Nr("\u2a74","\\Coloneqq"),Nr("\\ratio","\\vcentcolon"),Nr("\\coloncolon","\\dblcolon"),Nr("\\colonequals","\\coloneqq"),Nr("\\coloncolonequals","\\Coloneqq"),Nr("\\equalscolon","\\eqqcolon"),Nr("\\equalscoloncolon","\\Eqqcolon"),Nr("\\colonminus","\\coloneq"),Nr("\\coloncolonminus","\\Coloneq"),Nr("\\minuscolon","\\eqcolon"),Nr("\\minuscoloncolon","\\Eqcolon"),Nr("\\coloncolonapprox","\\Colonapprox"),Nr("\\coloncolonsim","\\Colonsim"),Nr("\\simcolon","\\mathrel{\\sim\\mathrel{\\mkern-1.2mu}\\vcentcolon}"),Nr("\\simcoloncolon","\\mathrel{\\sim\\mathrel{\\mkern-1.2mu}\\dblcolon}"),Nr("\\approxcolon","\\mathrel{\\approx\\mathrel{\\mkern-1.2mu}\\vcentcolon}"),Nr("\\approxcoloncolon","\\mathrel{\\approx\\mathrel{\\mkern-1.2mu}\\dblcolon}"),Nr("\\notni","\\html@mathml{\\not\\ni}{\\mathrel{\\char`\u220c}}"),Nr("\\limsup","\\DOTSB\\operatorname*{lim\\,sup}"),Nr("\\liminf","\\DOTSB\\operatorname*{lim\\,inf}"),Nr("\\injlim","\\DOTSB\\operatorname*{inj\\,lim}"),Nr("\\projlim","\\DOTSB\\operatorname*{proj\\,lim}"),Nr("\\varlimsup","\\DOTSB\\operatorname*{\\overline{lim}}"),Nr("\\varliminf","\\DOTSB\\operatorname*{\\underline{lim}}"),Nr("\\varinjlim","\\DOTSB\\operatorname*{\\underrightarrow{lim}}"),Nr("\\varprojlim","\\DOTSB\\operatorname*{\\underleftarrow{lim}}"),Nr("\\gvertneqq","\\html@mathml{\\@gvertneqq}{\u2269}"),Nr("\\lvertneqq","\\html@mathml{\\@lvertneqq}{\u2268}"),Nr("\\ngeqq","\\html@mathml{\\@ngeqq}{\u2271}"),Nr("\\ngeqslant","\\html@mathml{\\@ngeqslant}{\u2271}"),Nr("\\nleqq","\\html@mathml{\\@nleqq}{\u2270}"),Nr("\\nleqslant","\\html@mathml{\\@nleqslant}{\u2270}"),Nr("\\nshortmid","\\html@mathml{\\@nshortmid}{\u2224}"),Nr("\\nshortparallel","\\html@mathml{\\@nshortparallel}{\u2226}"),Nr("\\nsubseteqq","\\html@mathml{\\@nsubseteqq}{\u2288}"),Nr("\\nsupseteqq","\\html@mathml{\\@nsupseteqq}{\u2289}"),Nr("\\varsubsetneq","\\html@mathml{\\@varsubsetneq}{\u228a}"),Nr("\\varsubsetneqq","\\html@mathml{\\@varsubsetneqq}{\u2acb}"),Nr("\\varsupsetneq","\\html@mathml{\\@varsupsetneq}{\u228b}"),Nr("\\varsupsetneqq","\\html@mathml{\\@varsupsetneqq}{\u2acc}"),Nr("\\imath","\\html@mathml{\\@imath}{\u0131}"),Nr("\\jmath","\\html@mathml{\\@jmath}{\u0237}"),Nr("\\llbracket","\\html@mathml{\\mathopen{[\\mkern-3.2mu[}}{\\mathopen{\\char`\u27e6}}"),Nr("\\rrbracket","\\html@mathml{\\mathclose{]\\mkern-3.2mu]}}{\\mathclose{\\char`\u27e7}}"),Nr("\u27e6","\\llbracket"),Nr("\u27e7","\\rrbracket"),Nr("\\lBrace","\\html@mathml{\\mathopen{\\{\\mkern-3.2mu[}}{\\mathopen{\\char`\u2983}}"),Nr("\\rBrace","\\html@mathml{\\mathclose{]\\mkern-3.2mu\\}}}{\\mathclose{\\char`\u2984}}"),Nr("\u2983","\\lBrace"),Nr("\u2984","\\rBrace"),Nr("\\minuso","\\mathbin{\\html@mathml{{\\mathrlap{\\mathchoice{\\kern{0.145em}}{\\kern{0.145em}}{\\kern{0.1015em}}{\\kern{0.0725em}}\\circ}{-}}}{\\char`\u29b5}}"),Nr("\u29b5","\\minuso"),Nr("\\darr","\\downarrow"),Nr("\\dArr","\\Downarrow"),Nr("\\Darr","\\Downarrow"),Nr("\\lang","\\langle"),Nr("\\rang","\\rangle"),Nr("\\uarr","\\uparrow"),Nr("\\uArr","\\Uparrow"),Nr("\\Uarr","\\Uparrow"),Nr("\\N","\\mathbb{N}"),Nr("\\R","\\mathbb{R}"),Nr("\\Z","\\mathbb{Z}"),Nr("\\alef","\\aleph"),Nr("\\alefsym","\\aleph"),Nr("\\Alpha","\\mathrm{A}"),Nr("\\Beta","\\mathrm{B}"),Nr("\\bull","\\bullet"),Nr("\\Chi","\\mathrm{X}"),Nr("\\clubs","\\clubsuit"),Nr("\\cnums","\\mathbb{C}"),Nr("\\Complex","\\mathbb{C}"),Nr("\\Dagger","\\ddagger"),Nr("\\diamonds","\\diamondsuit"),Nr("\\empty","\\emptyset"),Nr("\\Epsilon","\\mathrm{E}"),Nr("\\Eta","\\mathrm{H}"),Nr("\\exist","\\exists"),Nr("\\harr","\\leftrightarrow"),Nr("\\hArr","\\Leftrightarrow"),Nr("\\Harr","\\Leftrightarrow"),Nr("\\hearts","\\heartsuit"),Nr("\\image","\\Im"),Nr("\\infin","\\infty"),Nr("\\Iota","\\mathrm{I}"),Nr("\\isin","\\in"),Nr("\\Kappa","\\mathrm{K}"),Nr("\\larr","\\leftarrow"),Nr("\\lArr","\\Leftarrow"),Nr("\\Larr","\\Leftarrow"),Nr("\\lrarr","\\leftrightarrow"),Nr("\\lrArr","\\Leftrightarrow"),Nr("\\Lrarr","\\Leftrightarrow"),Nr("\\Mu","\\mathrm{M}"),Nr("\\natnums","\\mathbb{N}"),Nr("\\Nu","\\mathrm{N}"),Nr("\\Omicron","\\mathrm{O}"),Nr("\\plusmn","\\pm"),Nr("\\rarr","\\rightarrow"),Nr("\\rArr","\\Rightarrow"),Nr("\\Rarr","\\Rightarrow"),Nr("\\real","\\Re"),Nr("\\reals","\\mathbb{R}"),Nr("\\Reals","\\mathbb{R}"),Nr("\\Rho","\\mathrm{P}"),Nr("\\sdot","\\cdot"),Nr("\\sect","\\S"),Nr("\\spades","\\spadesuit"),Nr("\\sub","\\subset"),Nr("\\sube","\\subseteq"),Nr("\\supe","\\supseteq"),Nr("\\Tau","\\mathrm{T}"),Nr("\\thetasym","\\vartheta"),Nr("\\weierp","\\wp"),Nr("\\Zeta","\\mathrm{Z}"),Nr("\\argmin","\\DOTSB\\operatorname*{arg\\,min}"),Nr("\\argmax","\\DOTSB\\operatorname*{arg\\,max}"),Nr("\\plim","\\DOTSB\\mathop{\\operatorname{plim}}\\limits"),Nr("\\bra","\\mathinner{\\langle{#1}|}"),Nr("\\ket","\\mathinner{|{#1}\\rangle}"),Nr("\\braket","\\mathinner{\\langle{#1}\\rangle}"),Nr("\\Bra","\\left\\langle#1\\right|"),Nr("\\Ket","\\left|#1\\right\\rangle");const Hn=e=>t=>{const r=t.consumeArg().tokens,n=t.consumeArg().tokens,o=t.consumeArg().tokens,s=t.consumeArg().tokens,i=t.macros.get("|"),a=t.macros.get("\\|");t.macros.beginGroup();const l=t=>r=>{e&&(r.macros.set("|",i),o.length&&r.macros.set("\\|",a));let s=t;if(!t&&o.length){"|"===r.future().text&&(r.popToken(),s=!0)}return{tokens:s?o:n,numArgs:0}};t.macros.set("|",l(!1)),o.length&&t.macros.set("\\|",l(!0));const h=t.consumeArg().tokens,c=t.expandTokens([...s,...h,...r]);return t.macros.endGroup(),{tokens:c.reverse(),numArgs:0}};Nr("\\bra@ket",Hn(!1)),Nr("\\bra@set",Hn(!0)),Nr("\\Braket","\\bra@ket{\\left\\langle}{\\,\\middle\\vert\\,}{\\,\\middle\\vert\\,}{\\right\\rangle}"),Nr("\\Set","\\bra@set{\\left\\{\\:}{\\;\\middle\\vert\\;}{\\;\\middle\\Vert\\;}{\\:\\right\\}}"),Nr("\\set","\\bra@set{\\{\\,}{\\mid}{}{\\,\\}}"),Nr("\\angln","{\\angl n}"),Nr("\\blue","\\textcolor{##6495ed}{#1}"),Nr("\\orange","\\textcolor{##ffa500}{#1}"),Nr("\\pink","\\textcolor{##ff00af}{#1}"),Nr("\\red","\\textcolor{##df0030}{#1}"),Nr("\\green","\\textcolor{##28ae7b}{#1}"),Nr("\\gray","\\textcolor{gray}{#1}"),Nr("\\purple","\\textcolor{##9d38bd}{#1}"),Nr("\\blueA","\\textcolor{##ccfaff}{#1}"),Nr("\\blueB","\\textcolor{##80f6ff}{#1}"),Nr("\\blueC","\\textcolor{##63d9ea}{#1}"),Nr("\\blueD","\\textcolor{##11accd}{#1}"),Nr("\\blueE","\\textcolor{##0c7f99}{#1}"),Nr("\\tealA","\\textcolor{##94fff5}{#1}"),Nr("\\tealB","\\textcolor{##26edd5}{#1}"),Nr("\\tealC","\\textcolor{##01d1c1}{#1}"),Nr("\\tealD","\\textcolor{##01a995}{#1}"),Nr("\\tealE","\\textcolor{##208170}{#1}"),Nr("\\greenA","\\textcolor{##b6ffb0}{#1}"),Nr("\\greenB","\\textcolor{##8af281}{#1}"),Nr("\\greenC","\\textcolor{##74cf70}{#1}"),Nr("\\greenD","\\textcolor{##1fab54}{#1}"),Nr("\\greenE","\\textcolor{##0d923f}{#1}"),Nr("\\goldA","\\textcolor{##ffd0a9}{#1}"),Nr("\\goldB","\\textcolor{##ffbb71}{#1}"),Nr("\\goldC","\\textcolor{##ff9c39}{#1}"),Nr("\\goldD","\\textcolor{##e07d10}{#1}"),Nr("\\goldE","\\textcolor{##a75a05}{#1}"),Nr("\\redA","\\textcolor{##fca9a9}{#1}"),Nr("\\redB","\\textcolor{##ff8482}{#1}"),Nr("\\redC","\\textcolor{##f9685d}{#1}"),Nr("\\redD","\\textcolor{##e84d39}{#1}"),Nr("\\redE","\\textcolor{##bc2612}{#1}"),Nr("\\maroonA","\\textcolor{##ffbde0}{#1}"),Nr("\\maroonB","\\textcolor{##ff92c6}{#1}"),Nr("\\maroonC","\\textcolor{##ed5fa6}{#1}"),Nr("\\maroonD","\\textcolor{##ca337c}{#1}"),Nr("\\maroonE","\\textcolor{##9e034e}{#1}"),Nr("\\purpleA","\\textcolor{##ddd7ff}{#1}"),Nr("\\purpleB","\\textcolor{##c6b9fc}{#1}"),Nr("\\purpleC","\\textcolor{##aa87ff}{#1}"),Nr("\\purpleD","\\textcolor{##7854ab}{#1}"),Nr("\\purpleE","\\textcolor{##543b78}{#1}"),Nr("\\mintA","\\textcolor{##f5f9e8}{#1}"),Nr("\\mintB","\\textcolor{##edf2df}{#1}"),Nr("\\mintC","\\textcolor{##e0e5cc}{#1}"),Nr("\\grayA","\\textcolor{##f6f7f7}{#1}"),Nr("\\grayB","\\textcolor{##f0f1f2}{#1}"),Nr("\\grayC","\\textcolor{##e3e5e6}{#1}"),Nr("\\grayD","\\textcolor{##d6d8da}{#1}"),Nr("\\grayE","\\textcolor{##babec2}{#1}"),Nr("\\grayF","\\textcolor{##888d93}{#1}"),Nr("\\grayG","\\textcolor{##626569}{#1}"),Nr("\\grayH","\\textcolor{##3b3e40}{#1}"),Nr("\\grayI","\\textcolor{##21242c}{#1}"),Nr("\\kaBlue","\\textcolor{##314453}{#1}"),Nr("\\kaGreen","\\textcolor{##71B307}{#1}");const On={"^":!0,_:!0,"\\limits":!0,"\\nolimits":!0};class En{constructor(e,t,r){this.settings=void 0,this.expansionCount=void 0,this.lexer=void 0,this.macros=void 0,this.stack=void 0,this.mode=void 0,this.settings=t,this.expansionCount=0,this.feed(e),this.macros=new Tn(Bn,t.macros),this.mode=r,this.stack=[]}feed(e){this.lexer=new An(e,this.settings)}switchMode(e){this.mode=e}beginGroup(){this.macros.beginGroup()}endGroup(){this.macros.endGroup()}endGroups(){this.macros.endGroups()}future(){return 0===this.stack.length&&this.pushToken(this.lexer.lex()),this.stack[this.stack.length-1]}popToken(){return this.future(),this.stack.pop()}pushToken(e){this.stack.push(e)}pushTokens(e){this.stack.push(...e)}scanArgument(e){let t,r,n;if(e){if(this.consumeSpaces(),"["!==this.future().text)return null;t=this.popToken(),({tokens:n,end:r}=this.consumeArg(["]"]))}else({tokens:n,start:t,end:r}=this.consumeArg());return this.pushToken(new Ir("EOF",r.loc)),this.pushTokens(n),t.range(r,"")}consumeSpaces(){for(;;){if(" "!==this.future().text)break;this.stack.pop()}}consumeArg(e){const t=[],r=e&&e.length>0;r||this.consumeSpaces();const o=this.future();let s,i=0,a=0;do{if(s=this.popToken(),t.push(s),"{"===s.text)++i;else if("}"===s.text){if(--i,-1===i)throw new n("Extra }",s)}else if("EOF"===s.text)throw new n("Unexpected end of input in a macro argument, expected '"+(e&&r?e[a]:"}")+"'",s);if(e&&r)if((0===i||1===i&&"{"===e[a])&&s.text===e[a]){if(++a,a===e.length){t.splice(-a,a);break}}else a=0}while(0!==i||r);return"{"===o.text&&"}"===t[t.length-1].text&&(t.pop(),t.shift()),t.reverse(),{tokens:t,start:o,end:s}}consumeArgs(e,t){if(t){if(t.length!==e+1)throw new n("The length of delimiters doesn't match the number of args!");const r=t[0];for(let e=0;e<r.length;e++){const t=this.popToken();if(r[e]!==t.text)throw new n("Use of the macro doesn't match its definition",t)}}const r=[];for(let n=0;n<e;n++)r.push(this.consumeArg(t&&t[n+1]).tokens);return r}countExpansion(e){if(this.expansionCount+=e,this.expansionCount>this.settings.maxExpand)throw new n("Too many expansions: infinite loop or need to increase maxExpand setting")}expandOnce(e){const t=this.popToken(),r=t.text,o=t.noexpand?null:this._getExpansion(r);if(null==o||e&&o.unexpandable){if(e&&null==o&&"\\"===r[0]&&!this.isDefined(r))throw new n("Undefined control sequence: "+r);return this.pushToken(t),!1}this.countExpansion(1);let s=o.tokens;const i=this.consumeArgs(o.numArgs,o.delimiters);if(o.numArgs){s=s.slice();for(let e=s.length-1;e>=0;--e){let t=s[e];if("#"===t.text){if(0===e)throw new n("Incomplete placeholder at end of macro body",t);if(t=s[--e],"#"===t.text)s.splice(e+1,1);else{if(!/^[1-9]$/.test(t.text))throw new n("Not a valid argument number",t);s.splice(e,2,...i[+t.text-1])}}}}return this.pushTokens(s),s.length}expandAfterFuture(){return this.expandOnce(),this.future()}expandNextToken(){for(;;)if(!1===this.expandOnce()){const e=this.stack.pop();return e.treatAsRelax&&(e.text="\\relax"),e}throw new Error}expandMacro(e){return this.macros.has(e)?this.expandTokens([new Ir(e)]):void 0}expandTokens(e){const t=[],r=this.stack.length;for(this.pushTokens(e);this.stack.length>r;)if(!1===this.expandOnce(!0)){const e=this.stack.pop();e.treatAsRelax&&(e.noexpand=!1,e.treatAsRelax=!1),t.push(e)}return this.countExpansion(t.length),t}expandMacroAsText(e){const t=this.expandMacro(e);return t?t.map((e=>e.text)).join(""):t}_getExpansion(e){const t=this.macros.get(e);if(null==t)return t;if(1===e.length){const t=this.lexer.catcodes[e];if(null!=t&&13!==t)return}const r="function"==typeof t?t(this):t;if("string"==typeof r){let e=0;if(-1!==r.indexOf("#")){const t=r.replace(/##/g,"");for(;-1!==t.indexOf("#"+(e+1));)++e}const t=new An(r,this.settings),n=[];let o=t.lex();for(;"EOF"!==o.text;)n.push(o),o=t.lex();n.reverse();return{tokens:n,numArgs:e}}return r}isDefined(e){return this.macros.has(e)||wn.hasOwnProperty(e)||se.math.hasOwnProperty(e)||se.text.hasOwnProperty(e)||On.hasOwnProperty(e)}isExpandable(e){const t=this.macros.get(e);return null!=t?"string"==typeof t||"function"==typeof t||!t.unexpandable:wn.hasOwnProperty(e)&&!wn[e].primitive}}const Ln=/^[\u208a\u208b\u208c\u208d\u208e\u2080\u2081\u2082\u2083\u2084\u2085\u2086\u2087\u2088\u2089\u2090\u2091\u2095\u1d62\u2c7c\u2096\u2097\u2098\u2099\u2092\u209a\u1d63\u209b\u209c\u1d64\u1d65\u2093\u1d66\u1d67\u1d68\u1d69\u1d6a]/,Dn=Object.freeze({"\u208a":"+","\u208b":"-","\u208c":"=","\u208d":"(","\u208e":")","\u2080":"0","\u2081":"1","\u2082":"2","\u2083":"3","\u2084":"4","\u2085":"5","\u2086":"6","\u2087":"7","\u2088":"8","\u2089":"9","\u2090":"a","\u2091":"e","\u2095":"h","\u1d62":"i","\u2c7c":"j","\u2096":"k","\u2097":"l","\u2098":"m","\u2099":"n","\u2092":"o","\u209a":"p","\u1d63":"r","\u209b":"s","\u209c":"t","\u1d64":"u","\u1d65":"v","\u2093":"x","\u1d66":"\u03b2","\u1d67":"\u03b3","\u1d68":"\u03c1","\u1d69":"\u03d5","\u1d6a":"\u03c7","\u207a":"+","\u207b":"-","\u207c":"=","\u207d":"(","\u207e":")","\u2070":"0","\xb9":"1","\xb2":"2","\xb3":"3","\u2074":"4","\u2075":"5","\u2076":"6","\u2077":"7","\u2078":"8","\u2079":"9","\u1d2c":"A","\u1d2e":"B","\u1d30":"D","\u1d31":"E","\u1d33":"G","\u1d34":"H","\u1d35":"I","\u1d36":"J","\u1d37":"K","\u1d38":"L","\u1d39":"M","\u1d3a":"N","\u1d3c":"O","\u1d3e":"P","\u1d3f":"R","\u1d40":"T","\u1d41":"U","\u2c7d":"V","\u1d42":"W","\u1d43":"a","\u1d47":"b","\u1d9c":"c","\u1d48":"d","\u1d49":"e","\u1da0":"f","\u1d4d":"g","\u02b0":"h","\u2071":"i","\u02b2":"j","\u1d4f":"k","\u02e1":"l","\u1d50":"m","\u207f":"n","\u1d52":"o","\u1d56":"p","\u02b3":"r","\u02e2":"s","\u1d57":"t","\u1d58":"u","\u1d5b":"v","\u02b7":"w","\u02e3":"x","\u02b8":"y","\u1dbb":"z","\u1d5d":"\u03b2","\u1d5e":"\u03b3","\u1d5f":"\u03b4","\u1d60":"\u03d5","\u1d61":"\u03c7","\u1dbf":"\u03b8"}),Vn={"\u0301":{text:"\\'",math:"\\acute"},"\u0300":{text:"\\`",math:"\\grave"},"\u0308":{text:'\\"',math:"\\ddot"},"\u0303":{text:"\\~",math:"\\tilde"},"\u0304":{text:"\\=",math:"\\bar"},"\u0306":{text:"\\u",math:"\\breve"},"\u030c":{text:"\\v",math:"\\check"},"\u0302":{text:"\\^",math:"\\hat"},"\u0307":{text:"\\.",math:"\\dot"},"\u030a":{text:"\\r",math:"\\mathring"},"\u030b":{text:"\\H"},"\u0327":{text:"\\c"}},Pn={"\xe1":"a\u0301","\xe0":"a\u0300","\xe4":"a\u0308","\u01df":"a\u0308\u0304","\xe3":"a\u0303","\u0101":"a\u0304","\u0103":"a\u0306","\u1eaf":"a\u0306\u0301","\u1eb1":"a\u0306\u0300","\u1eb5":"a\u0306\u0303","\u01ce":"a\u030c","\xe2":"a\u0302","\u1ea5":"a\u0302\u0301","\u1ea7":"a\u0302\u0300","\u1eab":"a\u0302\u0303","\u0227":"a\u0307","\u01e1":"a\u0307\u0304","\xe5":"a\u030a","\u01fb":"a\u030a\u0301","\u1e03":"b\u0307","\u0107":"c\u0301","\u1e09":"c\u0327\u0301","\u010d":"c\u030c","\u0109":"c\u0302","\u010b":"c\u0307","\xe7":"c\u0327","\u010f":"d\u030c","\u1e0b":"d\u0307","\u1e11":"d\u0327","\xe9":"e\u0301","\xe8":"e\u0300","\xeb":"e\u0308","\u1ebd":"e\u0303","\u0113":"e\u0304","\u1e17":"e\u0304\u0301","\u1e15":"e\u0304\u0300","\u0115":"e\u0306","\u1e1d":"e\u0327\u0306","\u011b":"e\u030c","\xea":"e\u0302","\u1ebf":"e\u0302\u0301","\u1ec1":"e\u0302\u0300","\u1ec5":"e\u0302\u0303","\u0117":"e\u0307","\u0229":"e\u0327","\u1e1f":"f\u0307","\u01f5":"g\u0301","\u1e21":"g\u0304","\u011f":"g\u0306","\u01e7":"g\u030c","\u011d":"g\u0302","\u0121":"g\u0307","\u0123":"g\u0327","\u1e27":"h\u0308","\u021f":"h\u030c","\u0125":"h\u0302","\u1e23":"h\u0307","\u1e29":"h\u0327","\xed":"i\u0301","\xec":"i\u0300","\xef":"i\u0308","\u1e2f":"i\u0308\u0301","\u0129":"i\u0303","\u012b":"i\u0304","\u012d":"i\u0306","\u01d0":"i\u030c","\xee":"i\u0302","\u01f0":"j\u030c","\u0135":"j\u0302","\u1e31":"k\u0301","\u01e9":"k\u030c","\u0137":"k\u0327","\u013a":"l\u0301","\u013e":"l\u030c","\u013c":"l\u0327","\u1e3f":"m\u0301","\u1e41":"m\u0307","\u0144":"n\u0301","\u01f9":"n\u0300","\xf1":"n\u0303","\u0148":"n\u030c","\u1e45":"n\u0307","\u0146":"n\u0327","\xf3":"o\u0301","\xf2":"o\u0300","\xf6":"o\u0308","\u022b":"o\u0308\u0304","\xf5":"o\u0303","\u1e4d":"o\u0303\u0301","\u1e4f":"o\u0303\u0308","\u022d":"o\u0303\u0304","\u014d":"o\u0304","\u1e53":"o\u0304\u0301","\u1e51":"o\u0304\u0300","\u014f":"o\u0306","\u01d2":"o\u030c","\xf4":"o\u0302","\u1ed1":"o\u0302\u0301","\u1ed3":"o\u0302\u0300","\u1ed7":"o\u0302\u0303","\u022f":"o\u0307","\u0231":"o\u0307\u0304","\u0151":"o\u030b","\u1e55":"p\u0301","\u1e57":"p\u0307","\u0155":"r\u0301","\u0159":"r\u030c","\u1e59":"r\u0307","\u0157":"r\u0327","\u015b":"s\u0301","\u1e65":"s\u0301\u0307","\u0161":"s\u030c","\u1e67":"s\u030c\u0307","\u015d":"s\u0302","\u1e61":"s\u0307","\u015f":"s\u0327","\u1e97":"t\u0308","\u0165":"t\u030c","\u1e6b":"t\u0307","\u0163":"t\u0327","\xfa":"u\u0301","\xf9":"u\u0300","\xfc":"u\u0308","\u01d8":"u\u0308\u0301","\u01dc":"u\u0308\u0300","\u01d6":"u\u0308\u0304","\u01da":"u\u0308\u030c","\u0169":"u\u0303","\u1e79":"u\u0303\u0301","\u016b":"u\u0304","\u1e7b":"u\u0304\u0308","\u016d":"u\u0306","\u01d4":"u\u030c","\xfb":"u\u0302","\u016f":"u\u030a","\u0171":"u\u030b","\u1e7d":"v\u0303","\u1e83":"w\u0301","\u1e81":"w\u0300","\u1e85":"w\u0308","\u0175":"w\u0302","\u1e87":"w\u0307","\u1e98":"w\u030a","\u1e8d":"x\u0308","\u1e8b":"x\u0307","\xfd":"y\u0301","\u1ef3":"y\u0300","\xff":"y\u0308","\u1ef9":"y\u0303","\u0233":"y\u0304","\u0177":"y\u0302","\u1e8f":"y\u0307","\u1e99":"y\u030a","\u017a":"z\u0301","\u017e":"z\u030c","\u1e91":"z\u0302","\u017c":"z\u0307","\xc1":"A\u0301","\xc0":"A\u0300","\xc4":"A\u0308","\u01de":"A\u0308\u0304","\xc3":"A\u0303","\u0100":"A\u0304","\u0102":"A\u0306","\u1eae":"A\u0306\u0301","\u1eb0":"A\u0306\u0300","\u1eb4":"A\u0306\u0303","\u01cd":"A\u030c","\xc2":"A\u0302","\u1ea4":"A\u0302\u0301","\u1ea6":"A\u0302\u0300","\u1eaa":"A\u0302\u0303","\u0226":"A\u0307","\u01e0":"A\u0307\u0304","\xc5":"A\u030a","\u01fa":"A\u030a\u0301","\u1e02":"B\u0307","\u0106":"C\u0301","\u1e08":"C\u0327\u0301","\u010c":"C\u030c","\u0108":"C\u0302","\u010a":"C\u0307","\xc7":"C\u0327","\u010e":"D\u030c","\u1e0a":"D\u0307","\u1e10":"D\u0327","\xc9":"E\u0301","\xc8":"E\u0300","\xcb":"E\u0308","\u1ebc":"E\u0303","\u0112":"E\u0304","\u1e16":"E\u0304\u0301","\u1e14":"E\u0304\u0300","\u0114":"E\u0306","\u1e1c":"E\u0327\u0306","\u011a":"E\u030c","\xca":"E\u0302","\u1ebe":"E\u0302\u0301","\u1ec0":"E\u0302\u0300","\u1ec4":"E\u0302\u0303","\u0116":"E\u0307","\u0228":"E\u0327","\u1e1e":"F\u0307","\u01f4":"G\u0301","\u1e20":"G\u0304","\u011e":"G\u0306","\u01e6":"G\u030c","\u011c":"G\u0302","\u0120":"G\u0307","\u0122":"G\u0327","\u1e26":"H\u0308","\u021e":"H\u030c","\u0124":"H\u0302","\u1e22":"H\u0307","\u1e28":"H\u0327","\xcd":"I\u0301","\xcc":"I\u0300","\xcf":"I\u0308","\u1e2e":"I\u0308\u0301","\u0128":"I\u0303","\u012a":"I\u0304","\u012c":"I\u0306","\u01cf":"I\u030c","\xce":"I\u0302","\u0130":"I\u0307","\u0134":"J\u0302","\u1e30":"K\u0301","\u01e8":"K\u030c","\u0136":"K\u0327","\u0139":"L\u0301","\u013d":"L\u030c","\u013b":"L\u0327","\u1e3e":"M\u0301","\u1e40":"M\u0307","\u0143":"N\u0301","\u01f8":"N\u0300","\xd1":"N\u0303","\u0147":"N\u030c","\u1e44":"N\u0307","\u0145":"N\u0327","\xd3":"O\u0301","\xd2":"O\u0300","\xd6":"O\u0308","\u022a":"O\u0308\u0304","\xd5":"O\u0303","\u1e4c":"O\u0303\u0301","\u1e4e":"O\u0303\u0308","\u022c":"O\u0303\u0304","\u014c":"O\u0304","\u1e52":"O\u0304\u0301","\u1e50":"O\u0304\u0300","\u014e":"O\u0306","\u01d1":"O\u030c","\xd4":"O\u0302","\u1ed0":"O\u0302\u0301","\u1ed2":"O\u0302\u0300","\u1ed6":"O\u0302\u0303","\u022e":"O\u0307","\u0230":"O\u0307\u0304","\u0150":"O\u030b","\u1e54":"P\u0301","\u1e56":"P\u0307","\u0154":"R\u0301","\u0158":"R\u030c","\u1e58":"R\u0307","\u0156":"R\u0327","\u015a":"S\u0301","\u1e64":"S\u0301\u0307","\u0160":"S\u030c","\u1e66":"S\u030c\u0307","\u015c":"S\u0302","\u1e60":"S\u0307","\u015e":"S\u0327","\u0164":"T\u030c","\u1e6a":"T\u0307","\u0162":"T\u0327","\xda":"U\u0301","\xd9":"U\u0300","\xdc":"U\u0308","\u01d7":"U\u0308\u0301","\u01db":"U\u0308\u0300","\u01d5":"U\u0308\u0304","\u01d9":"U\u0308\u030c","\u0168":"U\u0303","\u1e78":"U\u0303\u0301","\u016a":"U\u0304","\u1e7a":"U\u0304\u0308","\u016c":"U\u0306","\u01d3":"U\u030c","\xdb":"U\u0302","\u016e":"U\u030a","\u0170":"U\u030b","\u1e7c":"V\u0303","\u1e82":"W\u0301","\u1e80":"W\u0300","\u1e84":"W\u0308","\u0174":"W\u0302","\u1e86":"W\u0307","\u1e8c":"X\u0308","\u1e8a":"X\u0307","\xdd":"Y\u0301","\u1ef2":"Y\u0300","\u0178":"Y\u0308","\u1ef8":"Y\u0303","\u0232":"Y\u0304","\u0176":"Y\u0302","\u1e8e":"Y\u0307","\u0179":"Z\u0301","\u017d":"Z\u030c","\u1e90":"Z\u0302","\u017b":"Z\u0307","\u03ac":"\u03b1\u0301","\u1f70":"\u03b1\u0300","\u1fb1":"\u03b1\u0304","\u1fb0":"\u03b1\u0306","\u03ad":"\u03b5\u0301","\u1f72":"\u03b5\u0300","\u03ae":"\u03b7\u0301","\u1f74":"\u03b7\u0300","\u03af":"\u03b9\u0301","\u1f76":"\u03b9\u0300","\u03ca":"\u03b9\u0308","\u0390":"\u03b9\u0308\u0301","\u1fd2":"\u03b9\u0308\u0300","\u1fd1":"\u03b9\u0304","\u1fd0":"\u03b9\u0306","\u03cc":"\u03bf\u0301","\u1f78":"\u03bf\u0300","\u03cd":"\u03c5\u0301","\u1f7a":"\u03c5\u0300","\u03cb":"\u03c5\u0308","\u03b0":"\u03c5\u0308\u0301","\u1fe2":"\u03c5\u0308\u0300","\u1fe1":"\u03c5\u0304","\u1fe0":"\u03c5\u0306","\u03ce":"\u03c9\u0301","\u1f7c":"\u03c9\u0300","\u038e":"\u03a5\u0301","\u1fea":"\u03a5\u0300","\u03ab":"\u03a5\u0308","\u1fe9":"\u03a5\u0304","\u1fe8":"\u03a5\u0306","\u038f":"\u03a9\u0301","\u1ffa":"\u03a9\u0300"};class Fn{constructor(e,t){this.mode=void 0,this.gullet=void 0,this.settings=void 0,this.leftrightDepth=void 0,this.nextToken=void 0,this.mode="math",this.gullet=new En(e,t,this.mode),this.settings=t,this.leftrightDepth=0}expect(e,t){if(void 0===t&&(t=!0),this.fetch().text!==e)throw new n("Expected '"+e+"', got '"+this.fetch().text+"'",this.fetch());t&&this.consume()}consume(){this.nextToken=null}fetch(){return null==this.nextToken&&(this.nextToken=this.gullet.expandNextToken()),this.nextToken}switchMode(e){this.mode=e,this.gullet.switchMode(e)}parse(){this.settings.globalGroup||this.gullet.beginGroup(),this.settings.colorIsTextColor&&this.gullet.macros.set("\\color","\\textcolor");try{const e=this.parseExpression(!1);return this.expect("EOF"),this.settings.globalGroup||this.gullet.endGroup(),e}finally{this.gullet.endGroups()}}subparse(e){const t=this.nextToken;this.consume(),this.gullet.pushToken(new Ir("}")),this.gullet.pushTokens(e);const r=this.parseExpression(!1);return this.expect("}"),this.nextToken=t,r}parseExpression(e,t){const r=[];for(;;){"math"===this.mode&&this.consumeSpaces();const n=this.fetch();if(-1!==Fn.endOfExpression.indexOf(n.text))break;if(t&&n.text===t)break;if(e&&wn[n.text]&&wn[n.text].infix)break;const o=this.parseAtom(t);if(!o)break;"internal"!==o.type&&r.push(o)}return"text"===this.mode&&this.formLigatures(r),this.handleInfixNodes(r)}handleInfixNodes(e){let t,r=-1;for(let o=0;o<e.length;o++)if("infix"===e[o].type){if(-1!==r)throw new n("only one infix operator per group",e[o].token);r=o,t=e[o].replaceWith}if(-1!==r&&t){let n,o;const s=e.slice(0,r),i=e.slice(r+1);let a;return n=1===s.length&&"ordgroup"===s[0].type?s[0]:{type:"ordgroup",mode:this.mode,body:s},o=1===i.length&&"ordgroup"===i[0].type?i[0]:{type:"ordgroup",mode:this.mode,body:i},a="\\\\abovefrac"===t?this.callFunction(t,[n,e[r],o],[]):this.callFunction(t,[n,o],[]),[a]}return e}handleSupSubscript(e){const t=this.fetch(),r=t.text;let o;this.consume(),this.consumeSpaces();do{var s;o=this.parseGroup(e)}while("internal"===(null==(s=o)?void 0:s.type));if(!o)throw new n("Expected group after '"+r+"'",t);return o}formatUnsupportedCmd(e){const t=[];for(let r=0;r<e.length;r++)t.push({type:"textord",mode:"text",text:e[r]});const r={type:"text",mode:this.mode,body:t};return{type:"color",mode:this.mode,color:this.settings.errorColor,body:[r]}}parseAtom(e){const t=this.parseGroup("atom",e);if("internal"===(null==t?void 0:t.type))return t;if("text"===this.mode)return t;let r,o;for(;;){this.consumeSpaces();const e=this.fetch();if("\\limits"===e.text||"\\nolimits"===e.text){if(t&&"op"===t.type){const r="\\limits"===e.text;t.limits=r,t.alwaysHandleSupSub=!0}else{if(!t||"operatorname"!==t.type)throw new n("Limit controls must follow a math operator",e);t.alwaysHandleSupSub&&(t.limits="\\limits"===e.text)}this.consume()}else if("^"===e.text){if(r)throw new n("Double superscript",e);r=this.handleSupSubscript("superscript")}else if("_"===e.text){if(o)throw new n("Double subscript",e);o=this.handleSupSubscript("subscript")}else if("'"===e.text){if(r)throw new n("Double superscript",e);const t={type:"textord",mode:this.mode,text:"\\prime"},o=[t];for(this.consume();"'"===this.fetch().text;)o.push(t),this.consume();"^"===this.fetch().text&&o.push(this.handleSupSubscript("superscript")),r={type:"ordgroup",mode:this.mode,body:o}}else{if(!Dn[e.text])break;{const t=Ln.test(e.text),n=[];for(n.push(new Ir(Dn[e.text])),this.consume();;){const e=this.fetch().text;if(!Dn[e])break;if(Ln.test(e)!==t)break;n.unshift(new Ir(Dn[e])),this.consume()}const s=this.subparse(n);t?o={type:"ordgroup",mode:"math",body:s}:r={type:"ordgroup",mode:"math",body:s}}}}return r||o?{type:"supsub",mode:this.mode,base:t,sup:r,sub:o}:t}parseFunction(e,t){const r=this.fetch(),o=r.text,s=wn[o];if(!s)return null;if(this.consume(),t&&"atom"!==t&&!s.allowedInArgument)throw new n("Got function '"+o+"' with no arguments"+(t?" as "+t:""),r);if("text"===this.mode&&!s.allowedInText)throw new n("Can't use function '"+o+"' in text mode",r);if("math"===this.mode&&!1===s.allowedInMath)throw new n("Can't use function '"+o+"' in math mode",r);const{args:i,optArgs:a}=this.parseArguments(o,s);return this.callFunction(o,i,a,r,e)}callFunction(e,t,r,o,s){const i={funcName:e,parser:this,token:o,breakOnTokenText:s},a=wn[e];if(a&&a.handler)return a.handler(i,t,r);throw new n("No function handler for "+e)}parseArguments(e,t){const r=t.numArgs+t.numOptionalArgs;if(0===r)return{args:[],optArgs:[]};const o=[],s=[];for(let i=0;i<r;i++){let r=t.argTypes&&t.argTypes[i];const a=i<t.numOptionalArgs;(t.primitive&&null==r||"sqrt"===t.type&&1===i&&null==s[0])&&(r="primitive");const l=this.parseGroupOfType("argument to '"+e+"'",r,a);if(a)s.push(l);else{if(null==l)throw new n("Null argument, please report this as a bug");o.push(l)}}return{args:o,optArgs:s}}parseGroupOfType(e,t,r){switch(t){case"color":return this.parseColorGroup(r);case"size":return this.parseSizeGroup(r);case"url":return this.parseUrlGroup(r);case"math":case"text":return this.parseArgumentGroup(r,t);case"hbox":{const e=this.parseArgumentGroup(r,"text");return null!=e?{type:"styling",mode:e.mode,body:[e],style:"text"}:null}case"raw":{const e=this.parseStringGroup("raw",r);return null!=e?{type:"raw",mode:"text",string:e.text}:null}case"primitive":{if(r)throw new n("A primitive argument cannot be optional");const t=this.parseGroup(e);if(null==t)throw new n("Expected group as "+e,this.fetch());return t}case"original":case null:case void 0:return this.parseArgumentGroup(r);default:throw new n("Unknown group type as "+e,this.fetch())}}consumeSpaces(){for(;" "===this.fetch().text;)this.consume()}parseStringGroup(e,t){const r=this.gullet.scanArgument(t);if(null==r)return null;let n,o="";for(;"EOF"!==(n=this.fetch()).text;)o+=n.text,this.consume();return this.consume(),r.text=o,r}parseRegexGroup(e,t){const r=this.fetch();let o,s=r,i="";for(;"EOF"!==(o=this.fetch()).text&&e.test(i+o.text);)s=o,i+=s.text,this.consume();if(""===i)throw new n("Invalid "+t+": '"+r.text+"'",r);return r.range(s,i)}parseColorGroup(e){const t=this.parseStringGroup("color",e);if(null==t)return null;const r=/^(#[a-f0-9]{3}|#?[a-f0-9]{6}|[a-z]+)$/i.exec(t.text);if(!r)throw new n("Invalid color: '"+t.text+"'",t);let o=r[0];return/^[0-9a-f]{6}$/i.test(o)&&(o="#"+o),{type:"color-token",mode:this.mode,color:o}}parseSizeGroup(e){let t,r=!1;if(this.gullet.consumeSpaces(),t=e||"{"===this.gullet.future().text?this.parseStringGroup("size",e):this.parseRegexGroup(/^[-+]? *(?:$|\d+|\d+\.\d*|\.\d*) *[a-z]{0,2} *$/,"size"),!t)return null;e||0!==t.text.length||(t.text="0pt",r=!0);const o=/([-+]?) *(\d+(?:\.\d*)?|\.\d+) *([a-z]{2})/.exec(t.text);if(!o)throw new n("Invalid size: '"+t.text+"'",t);const s={number:+(o[1]+o[2]),unit:o[3]};if(!V(s))throw new n("Invalid unit: '"+s.unit+"'",t);return{type:"size",mode:this.mode,value:s,isBlank:r}}parseUrlGroup(e){this.gullet.lexer.setCatcode("%",13),this.gullet.lexer.setCatcode("~",12);const t=this.parseStringGroup("url",e);if(this.gullet.lexer.setCatcode("%",14),this.gullet.lexer.setCatcode("~",13),null==t)return null;const r=t.text.replace(/\\([#$%&~_^{}])/g,"$1");return{type:"url",mode:this.mode,url:r}}parseArgumentGroup(e,t){const r=this.gullet.scanArgument(e);if(null==r)return null;const n=this.mode;t&&this.switchMode(t),this.gullet.beginGroup();const o=this.parseExpression(!1,"EOF");this.expect("EOF"),this.gullet.endGroup();const s={type:"ordgroup",mode:this.mode,loc:r.loc,body:o};return t&&this.switchMode(n),s}parseGroup(e,t){const r=this.fetch(),o=r.text;let s;if("{"===o||"\\begingroup"===o){this.consume();const e="{"===o?"}":"\\endgroup";this.gullet.beginGroup();const t=this.parseExpression(!1,e),n=this.fetch();this.expect(e),this.gullet.endGroup(),s={type:"ordgroup",mode:this.mode,loc:qr.range(r,n),body:t,semisimple:"\\begingroup"===o||void 0}}else if(s=this.parseFunction(t,e)||this.parseSymbol(),null==s&&"\\"===o[0]&&!On.hasOwnProperty(o)){if(this.settings.throwOnError)throw new n("Undefined control sequence: "+o,r);s=this.formatUnsupportedCmd(o),this.consume()}return s}formLigatures(e){let t=e.length-1;for(let r=0;r<t;++r){const n=e[r],o=n.text;"-"===o&&"-"===e[r+1].text&&(r+1<t&&"-"===e[r+2].text?(e.splice(r,3,{type:"textord",mode:"text",loc:qr.range(n,e[r+2]),text:"---"}),t-=2):(e.splice(r,2,{type:"textord",mode:"text",loc:qr.range(n,e[r+1]),text:"--"}),t-=1)),"'"!==o&&"`"!==o||e[r+1].text!==o||(e.splice(r,2,{type:"textord",mode:"text",loc:qr.range(n,e[r+1]),text:o+o}),t-=1)}}parseSymbol(){const e=this.fetch();let t=e.text;if(/^\\verb[^a-zA-Z]/.test(t)){this.consume();let e=t.slice(5);const r="*"===e.charAt(0);if(r&&(e=e.slice(1)),e.length<2||e.charAt(0)!==e.slice(-1))throw new n("\\verb assertion failed --\n                    please report what input caused this bug");return e=e.slice(1,-1),{type:"verb",mode:"text",body:e,star:r}}Pn.hasOwnProperty(t[0])&&!se[this.mode][t[0]]&&(this.settings.strict&&"math"===this.mode&&this.settings.reportNonstrict("unicodeTextInMathMode",'Accented Unicode text character "'+t[0]+'" used in math mode',e),t=Pn[t[0]]+t.slice(1));const r=Mn.exec(t);let o;if(r&&(t=t.substring(0,r.index),"i"===t?t="\u0131":"j"===t&&(t="\u0237")),se[this.mode][t]){this.settings.strict&&"math"===this.mode&&Te.indexOf(t)>=0&&this.settings.reportNonstrict("unicodeTextInMathMode",'Latin-1/Unicode text character "'+t[0]+'" used in math mode',e);const r=se[this.mode][t].group,n=qr.range(e);let s;if(re.hasOwnProperty(r)){const e=r;s={type:"atom",mode:this.mode,family:e,loc:n,text:t}}else s={type:r,mode:this.mode,loc:n,text:t};o=s}else{if(!(t.charCodeAt(0)>=128))return null;this.settings.strict&&(S(t.charCodeAt(0))?"math"===this.mode&&this.settings.reportNonstrict("unicodeTextInMathMode",'Unicode text character "'+t[0]+'" used in math mode',e):this.settings.reportNonstrict("unknownSymbol",'Unrecognized Unicode character "'+t[0]+'" ('+t.charCodeAt(0)+")",e)),o={type:"textord",mode:"text",loc:qr.range(e),text:t}}if(this.consume(),r)for(let t=0;t<r[0].length;t++){const s=r[0][t];if(!Vn[s])throw new n("Unknown accent ' "+s+"'",e);const i=Vn[s][this.mode]||Vn[s].text;if(!i)throw new n("Accent "+s+" unsupported in "+this.mode+" mode",e);o={type:"accent",mode:this.mode,loc:qr.range(e),label:i,isStretchy:!1,isShifty:!0,base:o}}return o}}Fn.endOfExpression=["}","\\endgroup","\\end","\\right","&"];var Gn=function(e,t){if(!("string"==typeof e||e instanceof String))throw new TypeError("KaTeX can only parse string typed expression");const r=new Fn(e,t);delete r.gullet.macros.current["\\df@tag"];let o=r.parse();if(delete r.gullet.macros.current["\\current@color"],delete r.gullet.macros.current["\\color"],r.gullet.macros.get("\\df@tag")){if(!t.displayMode)throw new n("\\tag works only in display equations");o=[{type:"tag",mode:"text",body:o,tag:r.subparse([new Ir("\\df@tag")])}]}return o};let Un=function(e,t,r){t.textContent="";const n=Xn(e,r).toNode();t.appendChild(n)};"undefined"!=typeof document&&"CSS1Compat"!==document.compatMode&&("undefined"!=typeof console&&console.warn("Warning: KaTeX doesn't work in quirks mode. Make sure your website has a suitable doctype."),Un=function(){throw new n("KaTeX doesn't work in quirks mode.")});const Yn=function(e,t,r){if(r.throwOnError||!(e instanceof n))throw e;const o=Pe.makeSpan(["katex-error"],[new K(t)]);return o.setAttribute("title",e.toString()),o.setAttribute("style","color:"+r.errorColor),o},Xn=function(e,t){const r=new m(t);try{const t=Gn(e,r);return Tt(t,e,r)}catch(t){return Yn(t,e,r)}};var Wn={version:"0.16.22",render:Un,renderToString:function(e,t){return Xn(e,t).toMarkup()},ParseError:n,SETTINGS_SCHEMA:h,__parse:function(e,t){const r=new m(t);return Gn(e,r)},__renderToDomTree:Xn,__renderToHTMLTree:function(e,t){const r=new m(t);try{return function(e,t,r){const n=pt(e,zt(r)),o=Pe.makeSpan(["katex"],[n]);return At(o,r)}(Gn(e,r),0,r)}catch(t){return Yn(t,e,r)}},__setFontMetrics:function(e,t){T[e]=t},__defineSymbol:ie,__defineFunction:$e,__defineMacro:Nr,__domTree:{Span:_,Anchor:j,SymbolNode:K,SvgNode:J,PathNode:Q,LineNode:ee}};return t=t.default}()}));
\ No newline at end of file
diff --git a/src/formulas.ts b/src/formulas.ts
index 6f39066..38cb9ed 100644
--- a/src/formulas.ts
+++ b/src/formulas.ts
@@ -55,6 +55,73 @@ export interface FormulaIndex {
   warning?: string
 }
 
+/**
+ * `text` 块索引：**行内公式**（`$…$`）嵌在 `type:"text"` 块的 `text` 字段里，没有自己的
+ * bbox/equation 块（docs/selection-translate-requirements.md §2.1 实测：Dong 28/154、
+ * Hansen 22/112 个 text 块含 `$`）。划词翻译的服务端行内还原（§3.4）必须能拿到这些块。
+ *
+ * 只收「含 `$` 的 text 块」：全量 text 块会把 138KB 级的产物整篇搬进内存（§7 R15），
+ * 而还原只需要候选块。`text` 一律过 `compactLatex`（§2.5 实测：整块投影安全，
+ * `$F _ { \theta }$` → `$F_\theta$`，且片段外正文逐字节不变）。
+ */
+export interface TextBlockEntry {
+  /** 页码（1 起，= page_idx + 1） */
+  page: number
+  pageIdx: number
+  /** 页内序号（1 起，阅读序） */
+  index: number
+  /** [x0,y0,x1,y1]，归一化坐标（null = 该块没有可用 bbox） */
+  bbox: [number, number, number, number] | null
+  /** 紧凑投影后的块文本（`$…$` 片段已压紧） */
+  text: string
+}
+
+export interface TextBlockIndex {
+  source: 'mineru' | 'none'
+  blocks: TextBlockEntry[]
+  reason?: FormulaReason
+}
+
+/** 从 `.mineru.json` 的原始文本建 text 块索引（只收含 `$` 的块）。 */
+export function buildTextBlockIndex(raw: string | null): TextBlockIndex {
+  if (raw === null) return { source: 'none', blocks: [], reason: 'no-mineru-artifact' }
+
+  let parsed: unknown
+  try {
+    parsed = JSON.parse(raw)
+  } catch {
+    return { source: 'none', blocks: [], reason: 'bad-artifact' }
+  }
+  if (!isRecord(parsed)) return { source: 'none', blocks: [], reason: 'bad-artifact' }
+  const list = parsed['contentList']
+  if (!Array.isArray(list)) return { source: 'none', blocks: [], reason: 'bad-artifact' }
+
+  // page_idx 缺失的块沿用上一个有页码的块（与 buildFormulaIndex / transcribe 的投影口径一致）
+  const blocks: TextBlockEntry[] = []
+  const perPage = new Map<number, number>()
+  let lastPageIdx = 0
+  for (const b of list) {
+    if (!isRecord(b)) continue
+    if (b['type'] !== 'text') continue
+    const pi = b['page_idx']
+    if (typeof pi === 'number' && Number.isFinite(pi) && pi >= 0) lastPageIdx = Math.trunc(pi)
+    const text = b['text']
+    if (typeof text !== 'string' || !text.includes('$')) continue
+    const index = (perPage.get(lastPageIdx) ?? 0) + 1
+    perPage.set(lastPageIdx, index)
+    blocks.push({
+      page: lastPageIdx + 1,
+      pageIdx: lastPageIdx,
+      index,
+      bbox: toBbox(b['bbox']),
+      text: compactLatex(text),
+    })
+  }
+  // 注意：blocks 为空**不是**错误——产物可能根本没有含 `$` 的 text 块（行内还原直接
+  // 走 unavailable）。reason 只在「读不到 contentList」时给，语义与 FormulaReason 一致。
+  return { source: 'mineru', blocks }
+}
+
 /** 供测试与调用方复用的紧凑化：既有投影两步 + 算子名统一（见下）。 */
 export function compactLatex(rawLatex: string): string {
   return unifyOperatorNames(normalizeMathBraces(compressMathSpaces(rawLatex)))
@@ -253,32 +320,62 @@ export function buildFormulaIndex(raw: string | null, opts: { producer?: unknown
 // ── 读盘 + 记忆化（.mineru.json 实测 146KB/31 页，不能让每次渲染都读一遍）─────────
 interface CacheEntry { key: string; value: FormulaIndex }
 let cache: CacheEntry | null = null
+// 同一个 `.mineru.json` 现在有两个索引（equation 的 FormulaIndex 与行内公式用的
+// TextBlockIndex）。原始文本单读一层缓存：两个索引共用，避免 138KB 文件读两遍/解析两遍
+// 的放大（§7 R15）。key 同样是 `mtimeMs:size`——改名/重转录后自然失效。
+interface RawCacheEntry { key: string; raw: string | null }
+let rawCache: RawCacheEntry | null = null
+let textCache: { key: string; value: TextBlockIndex } | null = null
 
-/** 读 `<ref.mineruJsonPath>` 并建索引。文件缺失/损坏一律返回可用的空索引，**不抛异常**。 */
-export async function readFormulaIndex(ref: PaperRef): Promise<FormulaIndex> {
+/**
+ * 读 `.mineru.json` 原始文本（缺失 → null）。**不抛异常**：权限等异常也降级成 null，
+ * 由调用方决定 reason（读取失败按 bad-artifact 记）。
+ */
+async function readMineruRaw(ref: PaperRef): Promise<{ key: string; raw: string | null; failed?: string }> {
   let key = `${ref.mineruJsonPath}:absent`
   try {
     const st = await stat(ref.mineruJsonPath)
     key = `${ref.mineruJsonPath}:${st.mtimeMs}:${st.size}`
-    if (cache && cache.key === key) return cache.value
+    if (rawCache && rawCache.key === key) return { key, raw: rawCache.raw }
     const raw = await readFile(ref.mineruJsonPath, 'utf8')
-    const value = buildFormulaIndex(raw)
-    cache = { key, value }
-    return value
+    rawCache = { key, raw }
+    return { key, raw }
   } catch (err) {
     const code = (err as NodeJS.ErrnoException).code
     if (code === 'ENOENT' || code === 'EISDIR') {
-      const value = buildFormulaIndex(null)
-      if (cache?.key === key) return cache.value
-      cache = { key, value }
-      return value
+      if (!(rawCache && rawCache.key === key)) rawCache = { key, raw: null }
+      return { key, raw: null }
     }
-    // 权限等异常也不许把阅读器打崩：降级成 bad-artifact
-    return EMPTY('bad-artifact', `读取 mineru.json 失败：${code ?? 'unknown'}`)
+    return { key, raw: null, failed: code ?? 'unknown' }
   }
 }
 
+/** 读 `<ref.mineruJsonPath>` 并建索引。文件缺失/损坏一律返回可用的空索引，**不抛异常**。 */
+export async function readFormulaIndex(ref: PaperRef): Promise<FormulaIndex> {
+  const { key, raw, failed } = await readMineruRaw(ref)
+  if (failed !== undefined) return EMPTY('bad-artifact', `读取 mineru.json 失败：${failed}`)
+  if (cache && cache.key === key) return cache.value
+  const value = buildFormulaIndex(raw)
+  cache = { key, value }
+  return value
+}
+
+/**
+ * 读同一份产物并建 **text 块索引**（行内公式还原用，服务端内部；不经 `/api/formulas`
+ * 下发——§7 R14/R15 明确要求响应面不变）。与 `readFormulaIndex` 共用原始文本缓存。
+ */
+export async function readTextBlockIndex(ref: PaperRef): Promise<TextBlockIndex> {
+  const { key, raw, failed } = await readMineruRaw(ref)
+  if (failed !== undefined) return { source: 'none', blocks: [], reason: 'bad-artifact' }
+  if (textCache && textCache.key === key) return textCache.value
+  const value = buildTextBlockIndex(raw)
+  textCache = { key, value }
+  return value
+}
+
 /** 仅供测试：清空记忆化。 */
 export function resetFormulaCache(): void {
   cache = null
+  rawCache = null
+  textCache = null
 }
diff --git a/src/host.ts b/src/host.ts
index 2171253..cde42b3 100644
--- a/src/host.ts
+++ b/src/host.ts
@@ -33,7 +33,18 @@ import {
   resolveTopicDir,
   validateName,
 } from './library-manage.ts'
-import { readFormulaIndex } from './formulas.ts'
+import { readFormulaIndex, readTextBlockIndex } from './formulas.ts'
+import {
+  MAX_CHUNKS,
+  MAX_LATEX_CHARS,
+  MAX_TEXT_CHARS,
+  MAX_TOTAL_CHARS,
+  SelectionTranslateError,
+  assembleSource,
+  formulaStatusOf,
+  translateSelection,
+  type TranslateChunk,
+} from './translate-selection.ts'
 import { MineruError, sanitizeDetail } from './mineru.ts'
 import { readTranscript, transcribePaper, ScannedPdfError, ShortTextError, type SourceArg } from './transcribe.ts'
 import { pdfVariantPath, restartTranslation, startTranslation, zhStatus } from './translate.ts'
@@ -458,10 +469,17 @@ export function registerRoutes(ctx: Context, config: PluginConfig) {
         json(res, 400, { error: 'bad asset name' })
         return
       }
-      const mime: Record<string, string> = { '.mjs': 'text/javascript', '.js': 'text/javascript', '.css': 'text/css', '.map': 'application/json' }
+      const mime: Record<string, string> = { '.mjs': 'text/javascript', '.js': 'text/javascript', '.css': 'text/css', '.map': 'application/json',
+        // 字体（vendored KaTeX 的 woff2 就靠这条；不给对 MIME 时某些浏览器会拒绝 @font-face）
+        '.woff2': 'font/woff2', '.woff': 'font/woff', '.ttf': 'font/ttf' }
       try {
         const body = await readFile(new URL(name, readerVendorDir))
-        res.writeHead(200, { 'content-type': (mime[name.slice(name.lastIndexOf('.'))] ?? 'application/octet-stream') + '; charset=utf-8', 'content-length': body.length, 'cache-control': 'no-cache' })
+        const ext = name.slice(name.lastIndexOf('.'))
+        const type = mime[ext] ?? 'application/octet-stream'
+        // 只有文本类才追加 charset：给 font/woff2 这类二进制资源加 `; charset=utf-8` 是错的
+        // （实测 font/woff2 被浏览器按未知类型处理的风险；见 test/reader-vendor-http.test.mjs）
+        const texty = type.startsWith('text/') || type === 'application/json'
+        res.writeHead(200, { 'content-type': texty ? type + '; charset=utf-8' : type, 'content-length': body.length, 'cache-control': 'no-cache' })
         res.end(body)
       } catch {
         json(res, 404, { error: 'not found' })
@@ -834,6 +852,93 @@ export function registerRoutes(ctx: Context, config: PluginConfig) {
       return
     }
 
+    /* ── 划词翻译（公式保留，契约 docs/selection-translate-requirements.md §3.9）─────
+       客户端只送「按页 + 按 display 归属切好的 chunk」；行内公式的还原（选区文本 ↔ MinerU
+       text 块对齐）在服务端做，所以请求体里**没有任何矩形/bbox/pageSize**。
+       本接口只读（不写盘）⇒ 定位沿用 /api/formulas 的读路径语义，不做写路径边界。
+       API key 只存在于本进程：请求体只有 model（客户端从 /api/zh 拿到的 apiKeyHint 仅用于展示），
+       响应体与错误文案一律不带 key。 */
+    if (sub === '/api/translate-selection' && req.method === 'POST') {
+      const body = (await readBody(req)) as { topic?: unknown; name?: unknown; path?: unknown; chunks?: unknown }
+      const bad = (msg: string, code = 'bad-request') => json(res, 400, { error: msg, code })
+
+      if (!Array.isArray(body.chunks)) return bad('chunks 必须是数组')
+      if (body.chunks.length < 1 || body.chunks.length > MAX_CHUNKS) {
+        return bad(`chunks 数量必须在 1~${MAX_CHUNKS} 之间（收到 ${body.chunks.length}）`, 'too-large')
+      }
+      const chunks: TranslateChunk[] = []
+      let total = 0
+      for (const raw of body.chunks) {
+        if (typeof raw !== 'object' || raw === null) return bad('chunks 的每一项必须是对象')
+        const c = raw as { page?: unknown; kind?: unknown; text?: unknown; latex?: unknown }
+        const page = c.page
+        if (typeof page !== 'number' || !Number.isInteger(page) || page < 1) return bad('chunk.page 必须是 ≥1 的整数')
+        const text = typeof c.text === 'string' ? c.text : ''
+        const latex = typeof c.latex === 'string' ? c.latex : ''
+        if (c.kind === 'formula') {
+          if (!latex) return bad('formula chunk 的 latex 不能为空')
+          if (latex.length > MAX_LATEX_CHARS) return bad(`latex 超过 ${MAX_LATEX_CHARS} 字符`, 'too-large')
+          total += latex.length
+          chunks.push({ page, kind: 'formula', latex })
+          continue
+        }
+        if (c.kind !== 'text') return bad("chunk.kind 必须为 'text' 或 'formula'")
+        if (text.length > MAX_TEXT_CHARS) return bad(`text 超过 ${MAX_TEXT_CHARS} 字符`, 'too-large')
+        total += text.length
+        chunks.push({ page, kind: 'text', text })
+      }
+      if (total === 0) return bad('选区为空')
+      if (total > MAX_TOTAL_CHARS) return bad(`选区总长超过 ${MAX_TOTAL_CHARS} 字符`, 'too-large')
+
+      let ref: PaperRef
+      try {
+        const args: { path?: string; topic?: string; name?: string } = {}
+        if (typeof body.path === 'string' && body.path) args.path = body.path
+        else {
+          if (typeof body.topic !== 'string' || typeof body.name !== 'string' || !body.topic || !body.name) {
+            return bad('必须提供 topic + name（或 path）')
+          }
+          args.topic = body.topic
+          args.name = body.name
+        }
+        ref = resolvePaper(dataDir, args)
+      } catch {
+        throw notFound('文献不存在（划词翻译需要先能定位到该文献）')
+      }
+
+      const { endpoint, source } = await resolveTranslateEndpoint(config.translate)
+      if (source === 'none') {
+        json(res, 503, { error: '未配置翻译端点：在阅读器里点 ⚙ 填写（OpenAI 兼容端点即可）', code: 'no-endpoint' })
+        return
+      }
+      const index = await readTextBlockIndex(ref)
+      const asm = assembleSource(chunks, index)
+      try {
+        const r = await translateSelection(endpoint, asm.source)
+        json(res, 200, {
+          translation: r.translation,
+          model: r.model,
+          cached: r.cached,
+          formulaTotal: r.formulaTotal,
+          formulaKept: r.formulaKept,
+          formulaLost: r.formulaLost,
+          formulaApplied: asm.applied,
+          formulaSkipped: asm.skipped,
+          formulaStatus: formulaStatusOf(asm),
+          hasBlockIndex: asm.hasBlockIndex,
+          ms: r.ms,
+        })
+      } catch (err) {
+        if (!(err instanceof SelectionTranslateError)) throw err
+        json(res, err.status, {
+          error: err.message,
+          code: err.code,
+          ...(err.upstreamStatus !== null ? { upstreamStatus: err.upstreamStatus } : {}),
+        })
+      }
+      return
+    }
+
     // 新建伴读会话（会话N+1）。最新可见会话还是空白草稿时直接复用它——
     // 连点「新建」不再堆积空会话（毫无意义的点击什么都不存）。
     // n 用全量扫描分配（含归档/空白），绝不与磁盘上已有目录撞号。
diff --git a/src/translate-config.ts b/src/translate-config.ts
index 05b07dc..eaa4edb 100644
--- a/src/translate-config.ts
+++ b/src/translate-config.ts
@@ -124,6 +124,9 @@ export async function testTranslateEndpoint(ep: TranslateEndpoint): Promise<{ ok
     // Node 的 fetch 把真实原因（ECONNREFUSED / 证书错误 / 超时）塞在 cause 里，
     // 只报 "fetch failed" 对用户毫无帮助
     const cause = err instanceof Error && err.cause instanceof Error ? `: ${err.cause.message}` : ''
-    return { ok: false, detail: (err instanceof Error ? err.message : String(err)) + cause }
+    // ⚠️ t7（t4 评审 R-04 的同类项）：这条 detail 会进响应体、再上屏（设置浮层）。
+    // fetch 抛出的原因串可能带上 baseUrl（含凭据/查询参数）或回显 Authorization ——
+    // 与同函数上面两条分支一样先过 sanitizeDetail；可读原因（ECONNREFUSED 等）不受影响。
+    return { ok: false, detail: sanitizeDetail((err instanceof Error ? err.message : String(err)) + cause, apiKey) }
   }
 }
diff --git a/src/translate-selection.ts b/src/translate-selection.ts
new file mode 100644
index 0000000..ed70a0a
--- /dev/null
+++ b/src/translate-selection.ts
@@ -0,0 +1,852 @@
+// translate-selection.ts — 划词翻译（公式保留）的服务端核心。
+//
+// 契约：docs/selection-translate-requirements.md §3.3–§3.8（冻结 v1）。本模块只做**服务端**
+// 的部分，且全部纯函数化（`fetchImpl` 可注入 ⇒ 单测不需要网络、不产生费用）：
+//   ① `alignSelectionToBlock`：行内公式还原（文本层退化文本 ↔ MinerU text 块文本对齐，§3.4）
+//   ② `assembleSource`：把客户端的 chunk 序列组装成「公式已是单 $ 定界紧凑 LaTeX」的源文本
+//   ③ `buildRequestBody`：写死的 system 提示词 + §3.6 的请求体
+//   ④ `translateSelection`：调用端点（含唯一的 temperature 重试）+ 响应清洗 + 内存 LRU
+//   ⑤ `verifyFormulas`：把「译文原样保留公式」从口头要求变成可判定断言（§3.6-4）
+//
+// ⚠️ 为什么行内还原在服务端（§3.4 / C8）：客户端拿不到块文本；`compactLatex` 是 TS 侧函数，
+// 阅读器是单文件内联脚本、没有打包器，复制一份必然与 src/formulas.ts 漂移；而放在这里
+// 可以用 `node --test` 直接构造成本极低的攻击用例。
+//
+// ⚠️ 日志红线（§3.7③）：本模块**只**允许打印 `{model, status, ms, chars}` ——
+// 绝不把端点对象或配置对象送进日志，API key 不进日志、不进响应、不进错误文案。
+
+import { createHash } from 'node:crypto'
+import { compactLatex, type TextBlockIndex } from './formulas.ts'
+import { sanitizeDetail } from './mineru.ts'
+import type { TranslateEndpoint } from './translate.ts'
+
+/* ── 冻结参数表（§3.4；调参必须回改需求文档）────────────────────────────── */
+/** 最短可对齐归一化长度 */
+export const MIN_NORM = 4
+/** 种子长度上下限 */
+export const SEED_MAX = 12
+export const SEED_MIN = 4
+/** 跳过预算系数：`max(4, ceil(0.4*|S|))` */
+export const SKIP_RATIO = 0.4
+/** 接受阈值 */
+export const MIN_SCORE = 0.75
+/** 跨度长度比 `[0.6, 1.35]` */
+export const RATIO_LO = 0.6
+export const RATIO_HI = 1.35
+/** 同一 seed 的候选出现数 */
+export const SEED_TRIES = 3
+
+/* ── 规模上限（§3.9）────────────────────────────────────────────────────── */
+export const MAX_CHUNKS = 200
+export const MAX_TEXT_CHARS = 4000
+export const MAX_LATEX_CHARS = 2000
+export const MAX_TOTAL_CHARS = 8000
+/** 服务端上游超时（§3.6） */
+export const UPSTREAM_TIMEOUT_MS = 30_000
+/** LRU 上限（§3.7④） */
+export const CACHE_LIMIT = 200
+
+/* ── 提示词契约（§3.6，逐字冻结；改动必须回改需求文档并重跑 A6/A7）────────── */
+export const SELECTION_SYSTEM_PROMPT = `You are a professional, authentic machine translation engine for academic papers.
+Translate the user's input into Simplified Chinese.
+
+Hard rules:
+1. Any content wrapped in $...$ is a LaTeX formula. Keep every formula EXACTLY as
+   given: do not translate it, do not rewrite or simplify it, do not change spaces,
+   braces, or backslashes, do not drop it, do not add any.
+2. Output the translation ONLY. No preamble, no explanation, no notes, no headings,
+   no Markdown code fences, no quotes around the whole output.
+3. Preserve the paragraph and line structure of the input. Never add content that is
+   not in the input.
+4. Translate terminology by field convention (policy -> 策略, world model -> 世界模型).
+   Keep model names, dataset names, method names and abbreviations (LCVN-WM, DiT, CLIP)
+   in the original form.
+5. If the input is already Chinese, return it as is.`
+
+/* ── 错误类型（错误码表 §3.9）───────────────────────────────────────────── */
+export type SelectionErrorCode = 'no-endpoint' | 'bad-request' | 'too-large' | 'upstream' | 'network' | 'timeout'
+
+export class SelectionTranslateError extends Error {
+  constructor(
+    readonly code: SelectionErrorCode,
+    readonly status: number,
+    message: string,
+    /** 上游 HTTP 状态码（仅 code==='upstream' 时有意义）：客户端据此出 §3.7② 的分档文案 */
+    readonly upstreamStatus: number | null = null,
+  ) {
+    super(message)
+    this.name = 'SelectionTranslateError'
+  }
+}
+
+/* ── 文本清洗（§3.3②）──────────────────────────────────────────────────── */
+
+/** 文本层乱码字符类（§3.3② 的冻结清单）：C0/C1（\t 与 \n 是空白，另行折叠）、私用区、
+ *  U+FFFD、走音符号类。**只用于 `$…$` 之外的文本层内容**——见下面的 LaTeX 例外。 */
+function isTextJunk(cp: number): boolean {
+  if (cp <= 0x1f && cp !== 0x09 && cp !== 0x0a && cp !== 0x0b && cp !== 0x0c && cp !== 0x0d) return true
+  if (cp >= 0x7f && cp <= 0x9f) return true
+  if (cp >= 0xe000 && cp <= 0xf8ff) return true
+  if (cp === 0xfffd) return true
+  if (cp === 0x02c6 || cp === 0x02dc || cp === 0xb4 || cp === 0x005e || cp === 0x0060) return true
+  return cp >= 0x300 && cp <= 0x36f
+}
+
+const isLatexJunk = (cp: number): boolean =>
+  (cp <= 0x1f && cp !== 0x0a) || (cp >= 0x7f && cp <= 0x9f) || (cp >= 0xe000 && cp <= 0xf8ff) || cp === 0xfffd
+
+function dropJunk(s: string, junk: (cp: number) => boolean): string {
+  let out = ''
+  for (const ch of s) {
+    if (junk(ch.codePointAt(0) ?? 0)) continue
+    out += ch
+  }
+  return out
+}
+
+/** 空白折叠：连续空白（\t/\r/空格…）折叠成一个空格，**换行是结构**只清它两侧的空格。 */
+function collapse(s: string): string {
+  return s.replace(/[^\S\n]+/g, ' ').replace(/ *\n */g, '\n').replace(/\n{2,}/g, '\n').trim()
+}
+
+/**
+ * 收尾清洗：删除 C0/C1 控制字符、私用区（E000-F8FF）、U+FFFD、走音符号类
+ * （`\u02c6 \u02dc \u00b4 \u005e \u0060 \u0300-\u036f`），并把连续空白折叠成一个空格。
+ *
+ * **两条实现约束（都是实测/契约必需的，见实现报告）**：
+ *  ① `\n` 是结构：§3.5 ④「页之间插一个 `\n`」+ §3.6 system 第 3 条「保持行结构」，
+ *     所以只折叠它两侧的空格与连续空行。
+ *  ② 本函数**只能作用在 `$…$` 之外**：清单里的 `\u005e`（`^`）在 LaTeX 里是上标运算符，
+ *     整段组装文本过一遍会把 `v^\top` 变成 `v\top`、`x^2` 变成 `x2`（实测）——那既毁公式，
+ *     又会让「公式原样保留」的校验失去意义。`assembleSource` 因此对每个 piece 分类清洗：
+ *     `$…$` 内只删控制字符/私用区（`isLatexJunk`），外面才用本函数。
+ */
+export function stripJunk(s: string): string {
+  return collapse(dropJunk(s, isTextJunk))
+}
+
+/** 一个组装 piece 的清洗：`$…$` 内是 MinerU 的 LaTeX（逐字保留），外面是文本层内容（清乱码）。 */
+function cleanPiece(s: string): string {
+  return s.split(/(\$[^$]*\$)/)
+    .map((part) => (part.startsWith('$') && part.endsWith('$') && part.length >= 2
+      ? '$' + dropJunk(part.slice(1, -1), isLatexJunk) + '$'
+      : dropJunk(part, isTextJunk)))
+    .join('')
+}
+
+/**
+ * 中和文本层原文里的**字面 `$`**（R-03）：换成全角 `＄`（U+FF04）。
+ * 组装文本的 `$…$` 因此**只**可能是真公式（formula chunk 或块跨度里的 LaTeX 片段），
+ * `verifyFormulas` 的逐 token 校验才是可判定的；否则 `$5` 这种字面符会与别处的 `$` 配成
+ * 假片段，把真公式挤掉（A7 空转）。模型看到的仍是同一个货币符号的常见全角写法。
+ * 用于**未对齐分支**（那一段是文本层原文，里面不可能有 MinerU 的 LaTeX）。
+ */
+function neutralizeDollars(s: string): string {
+  return s.includes('$') ? s.replace(/\$/g, '\uff04') : s
+}
+
+/**
+ * 一个 `$…$` 片段**看起来是 LaTeX**吗（N-02 的判据）。
+ * 真公式来自 MinerU 的 LaTeX 投影：含命令/上下标/花括号（`\ _ ^ { } &`），或者整体**不含空白**
+ * （紧凑投影后的 `$x_t$`/`$F$` 这类纯符号公式）。正文里两个**字面** `$` 之间通常是自然语言
+ * （`$5 up to $`）——含空白且没有 LaTeX 字符 ⇒ 判为非公式。
+ *
+ * ⚠️ 已知边界：紧凑的成对字面 `$`（如正文写成 `$USD$`、`$5$`）与 `$F$` 这类纯符号公式形态相同，
+ * 无法区分，会按公式计入 token。本机两份语料（154+112 个 text 块、两条真实文本层）中不存在
+ * 这类形态；遇到时行为与旧版一致（计入并校验），不会更糟。
+ */
+export function isLatexLikeFragment(fragment: string): boolean {
+  const inner = fragment.startsWith('$') && fragment.endsWith('$') ? fragment.slice(1, -1) : fragment
+  if (/[\\_^{}&]/.test(inner)) return true
+  return !/\s/.test(inner)
+}
+
+/**
+ * 中和**块跨度**里的成对字面 `$`（N-02）：保留看起来是 LaTeX 的 `$…$` 片段（那是真公式），
+ * 其余 `$` 一律换成全角 `＄`。这样组装文本里的每个 `$…$` 都可判定为真公式，
+ * `formulaTokens`/`verifyFormulas` 不会再把 `$5 up to $` 当成公式（假警告）或塞进提示词。
+ */
+function neutralizeNonLatexPairs(s: string): string {
+  if (!s.includes('$')) return s
+  return s.split(/(\$[^$]*\$)/)
+    .map((part) => {
+      if (part.startsWith('$') && part.endsWith('$') && part.length >= 2 && isLatexLikeFragment(part)) return part
+      return part.replace(/\$/g, '\uff04')
+    })
+    .join('')
+}
+
+/** 对齐用的归一化：小写 + 只留 `[a-z0-9]` 与 CJK，其余（空白/标点/数学符号/控制字符）丢弃。 */
+export function normForAlign(raw: string): { A: string; idx: number[] } {
+  const chars: string[] = []
+  const idx: number[] = []
+  for (let i = 0; i < raw.length; i++) {
+    const c = raw[i]!.toLowerCase()
+    if (/[a-z0-9\u4e00-\u9fff]/.test(c)) {
+      chars.push(c)
+      idx.push(i)
+    }
+  }
+  return { A: chars.join(''), idx }
+}
+
+/* ── 行内对齐（§3.4，原型 .probe/align-sim4.mjs 的冻结版）──────────────────
+   ⚠️ t6 修复（t3 报告 F1/F2，见 docs/selection-translate-verification.md §6.1/§6.2）：
+   冻结版有两个缺陷，都是「静默送错文本」：
+     F1 跨度端点丢词：公式的 LaTeX 比文本层退化形态长得多（`\mathbf`/`\left`/`\right`/命令名），
+        双向行走的 skip 预算被这些「LaTeX 噪声」吃掉，于是在**选区侧**跳过公式前的正文词，
+        `bMin` 落在 `$` 上 → 组装文本少一个词（实测 `where …` 的 `where` 丢失）。
+     F2 张冠李戴：`score ≥ 0.75` 对短选区没有判别力（逐字母匹配 5/8 就 0.83），于是「本段不在
+        候选集里」时会被**别的段落**接走（`, while a learner encoder` → `expert and learner encoders`）。
+   修复（三条，均为「绝对门槛」，宁可拒绝还原并如实提示，也不许静默送错文本）：
+     ① **块侧跳过只允许发生在 `$…$` 片段内且不消耗预算**（LaTeX 命令/括号本来就无法被文本层
+        表示 ⇒ 它们是结构性差异，不是「多抓了内容」）。正文里的块侧跳字 = 张冠李戴 ⇒ 该候选作废。
+        这同时让行走能回到选区两端（F1 的根因）。
+     ② **端点回填**：行走仍够不到时（选区侧未配对的前缀/后缀），把它按同样的规则映射回块侧，
+        因此「选区里有、块里也有」的词一定进跨度（F1 §12.1 的处方）。
+     ③ **覆盖门槛**：跨度必须解释选区的**每一个字母**（未配对的字母只能是数字/符号，如公式编号
+        `(4)` 的 `4`），且跨度内不得出现「块侧多出来的散文内容」（prose slack，如选区是
+        `Instruction:` 而块里是 `instructions`）⇒ 否则拒绝（返回原样 + 走 §3.8 的诚实文案）。
+     另：跨度长度比 `ratio` 改用**内容口径**（`$…$` 内的 `\命令名` 不算内容）——旧口径把
+        `\mathbf`s_t=\left[…\right]` 的 15 个命令名字符算成选区内容，回填 `where` 后 ratio 反而
+        从 1.30 涨到 1.46 被误拒。阈值 `[0.6,1.35]`、`score≥0.75`、种子/预算参数**全部未动**。 */
+
+const WORD_CH = /[A-Za-z0-9]/
+
+/** `$…$` 片段范围（raw 下标）。 */
+function fragmentRanges(raw: string): Array<[number, number]> {
+  const out: Array<[number, number]> = []
+  const re = /\$[^$]*\$/g
+  let m: RegExpExecArray | null
+  while ((m = re.exec(raw)) !== null) out.push([m.index, m.index + m[0].length])
+  return out
+}
+
+/** 归一化下标 → 是否落在 `$…$` 片段内部（`$` 定界符本身不算内部）。 */
+function fragmentFlags(raw: string, Bidx: number[]): boolean[] {
+  const ranges = fragmentRanges(raw)
+  return Bidx.map((ri) => ranges.some(([f0, f1]) => ri > f0 && ri < f1))
+}
+
+/**
+ * 「内容」口径的归一化：`$…$` 内先删掉 LaTeX 命令名（`\mathbf`/`\left`/`\theta`…）与花括号/定界符，
+ * 只保留真正会被文本层呈现出来的字母数字。用于跨度长度比 `ratio`——文本层永远表示不出命令名，
+ * 把它们算进跨度长度等于用「LaTeX 写得多长」去衡量「有没有多抓一行」。
+ */
+export function contentNormForRatio(raw: string): string {
+  const ranges = fragmentRanges(raw)
+  let out = ''
+  for (let i = 0; i < raw.length; i++) {
+    const inFrag = ranges.some(([f0, f1]) => i > f0 && i < f1)
+    if (inFrag && raw[i] === '\\') {
+      i++
+      while (i + 1 < raw.length && /[A-Za-z]/.test(raw[i + 1]!)) i++
+      continue
+    }
+    out += raw[i]
+  }
+  return normForAlign(out).A
+}
+
+interface SeedHit { score: number; pairs: Array<[number, number]> }
+
+/** 种子 + 双向行走；块侧跳过必须整段落在 `$…$` 片段内（且免费），选区侧跳过消耗预算。 */
+function alignSeeds(S: string, B: string, inFrag: boolean[], skipRatio = SKIP_RATIO): SeedHit[] {
+  const k = Math.min(SEED_MAX, Math.max(SEED_MIN, Math.floor(S.length / 4)))
+  const seeds = [...new Set([0, Math.max(0, Math.floor((S.length - k) / 2)), Math.max(0, S.length - k)])]
+  const budget0 = Math.max(4, Math.ceil(skipRatio * S.length))
+  const walk = (Sx: string, Bx: string, frag: boolean[], ss: number, at: number): Array<[number, number]> => {
+    const pairs: Array<[number, number]> = []
+    let i = ss
+    let j = at
+    let budget = budget0
+    while (i < Sx.length && j < Bx.length) {
+      if (Sx[i] === Bx[j]) {
+        pairs.push([i, j])
+        i++
+        j++
+        continue
+      }
+      const nS = Bx.indexOf(Sx[i]!, j)  // 块侧：跳到该字符的下一次出现
+      let freeB = false
+      if (nS >= 0) {
+        freeB = true
+        for (let t = j; t < nS; t++) {
+          if (!frag[t]) { freeB = false; break }   // 跳过范围里含正文 → 张冠李戴，候选作废
+        }
+      }
+      const nB = Sx.indexOf(Bx[j]!, i)  // 选区侧多出的字符（文本层公式字形）→ 跳选区侧
+      const costS = nB < 0 ? Infinity : nB - i
+      if (freeB) { j = nS; continue }               // 片段内跳过：结构性差异，免费
+      if (costS === Infinity || costS > budget) break
+      budget -= costS
+      i += costS
+    }
+    return pairs
+  }
+  const rev = (s: string) => [...s].reverse().join('')
+  const Sr = rev(S)
+  const Br = rev(B)
+  const fragR = [...inFrag].reverse()
+  const out: SeedHit[] = []
+  for (const ss of seeds) {
+    const seed = S.slice(ss, ss + k)
+    if (seed.length < 4) continue
+    let at = B.indexOf(seed)
+    let tries = 0
+    while (at >= 0 && tries < SEED_TRIES) {
+      const R = walk(S, B, inFrag, ss, at)
+      const L = walk(Sr, Br, fragR, S.length - 1 - ss, B.length - 1 - at).map(
+        ([a, b]) => [S.length - 1 - a, B.length - 1 - b] as [number, number],
+      )
+      const pairs = R.concat(L)
+        .sort((a, b) => a[0] - b[0])
+        .filter((p, i, arr) => i === 0 || p[0] !== arr[i - 1]![0])
+      out.push({ score: pairs.length / S.length, pairs })
+      at = B.indexOf(seed, at + 1)
+      tries++
+    }
+  }
+  return out
+}
+
+/** ① 词边界外扩：端点不再是词字符为止（防 v1 实测的 `…solving the follo` 截断）。 */
+function expandWords(raw: string, a: number, b: number): [number, number] {
+  while (a > 0 && WORD_CH.test(raw[a - 1]!) && WORD_CH.test(raw[a] ?? '')) a--
+  while (b < raw.length && WORD_CH.test(raw[b] ?? '') && WORD_CH.test(raw[b - 1] ?? '')) b++
+  return [a, b]
+}
+
+/** ② 片段边界外扩：端点落在 `$…$` 内部时扩到片段边界（防切出半个公式）。 */
+function expandFragments(raw: string, a: number, b: number): [number, number] {
+  for (const [f0, f1] of fragmentRanges(raw)) {
+    if (a > f0 && a < f1) a = f0
+    if (b > f0 && b < f1) b = f1
+  }
+  return [a, b]
+}
+
+/**
+ * 端点回填（F1 的处方，§12.1）：选区侧**未配对的前缀/后缀**映射回块侧。
+ * 规则与行走一致：块侧跳过必须整段在 `$…$` 片段内，且总跳过量受同一预算约束；
+ * 只要有一字符映射不到，就整体放弃回填（绝不让端点落在猜出来的位置上）。
+ *
+ * ⚠️ **防御性代码：当前没有任何用例能区分它**（t4 评审 R-08 的独立变异 M16：把本函数关掉，
+ * 全量套件 0 红、真实 Dong 语料 0 差异；t7 又专门构造了「前缀 + N 个重复字形 + 公式」
+ * （N=5/20/40/80）与「公式在前、正文词在后 + 重复字形」等形态，仍然构造不出差异）。
+ * 原因是可论证的：规则 ① 让块侧跳过「只在 `$…$` 内且免费」之后，反向行走用**独立的**
+ * 预算从锚点一路回到选区开头；凡是回填能映射的前缀（在块里紧邻、只需片段内跳过），
+ * 反向行走同样能配对；而反向行走配不上的前缀，其间的块侧字符必含正文 —— 回填的
+ * 片段内检查也会同样失败。**F1 的真正修复是规则 ① + 覆盖门槛**（两者都有可区分的用例）。
+ * 保留本函数是纵深防御：万一将来放宽规则 ①，端点回填仍在（且不改变任何已接受的结果）。
+ */
+function backfillEnds(
+  S: string, B: string, inFrag: boolean[], p: number, q: number,
+  bMin: number, bMax: number, budget: number,
+): { lo: number | null; hi: number | null; covered: number } {
+  const out = { lo: null as number | null, hi: null as number | null, covered: 0 }
+  if (p > 0 && bMin > 0) {
+    let j = bMin - 1
+    let rest = budget
+    let earliest = -1
+    let ok = true
+    for (let i = p - 1; i >= 0; i--) {
+      const at = B.lastIndexOf(S[i]!, j)
+      if (at < 0 || j - at > rest) { ok = false; break }
+      for (let t = at + 1; t <= j; t++) { if (!inFrag[t]) { ok = false; break } }
+      if (!ok) break
+      rest -= j - at
+      j = at - 1
+      earliest = at
+    }
+    if (ok) { out.lo = earliest; out.covered += p }
+  }
+  if (q < S.length - 1 && bMax + 1 < B.length) {
+    let j = bMax + 1
+    let rest = budget
+    let latest = -1
+    let ok = true
+    for (let i = q + 1; i < S.length; i++) {
+      const at = B.indexOf(S[i]!, j)
+      if (at < 0 || at - j > rest) { ok = false; break }
+      for (let t = j; t < at; t++) { if (!inFrag[t]) { ok = false; break } }
+      if (!ok) break
+      rest -= at - j
+      j = at + 1
+      latest = at
+    }
+    if (ok) { out.hi = latest; out.covered += S.length - 1 - q }
+  }
+  return out
+}
+
+/** 选区原文最后一段词（小写；忽略行尾标点/连字符）。用于端点补词门槛。 */
+function trailingWordOf(chunkText: string): string {
+  const t = chunkText.replace(/[^A-Za-z0-9]+$/, '')
+  const m = /[A-Za-z0-9]+$/.exec(t)
+  return m ? m[0].toLowerCase() : ''
+}
+
+export interface AlignCandidate {
+  text: string
+  score: number
+  ratio: number
+  ok: boolean
+  /** 选区侧始终未被解释的字母（数字/符号允许，如公式编号）→ 非空即拒绝 */
+  unpairedLetters: string
+  /**
+   * 端点「补词」越界（非空即拒绝）：跨度末尾的词比选区末尾的词**更长**（expandWords 补全了词尾），
+   * 而选区原文并没有换行连字符 —— 例如选区 `Instruction:`（图注）被块里的 `instructions` 接走
+   * （t3 报告 §6.2 的同类现象）。带连字符的换行断词（`… with com-` ↔ `compact`）**必须放行**，
+   * 那是文本层的正常断行，t3 报告 §2.5 明确把它记为假阳性而不是缺陷。
+   */
+  completedTail: string
+}
+
+/** 单个（块, 种子）候选：求跨度 → 端点回填 → 三次修正 → `$` 校验 → 绝对门槛 + 长度保险。 */
+function candidateFor(S: string, raw: string, B: string, Bidx: number[], inFrag: boolean[], hit: SeedHit, chunkText: string): AlignCandidate | null {
+  if (!hit.pairs.length) return null
+  let bMin = Infinity
+  let bMax = -1
+  for (const [, b] of hit.pairs) {
+    if (b < bMin) bMin = b
+    if (b > bMax) bMax = b
+  }
+  const paired = new Set(hit.pairs.map((p) => p[0]))
+  let p = 0
+  while (p < S.length && !paired.has(p)) p++
+  let q = S.length - 1
+  while (q >= 0 && !paired.has(q)) q--
+  const bf = backfillEnds(S, B, inFrag, p, q, bMin, bMax, Math.max(4, Math.ceil(SKIP_RATIO * S.length)))
+  const loIdx = bf.lo ?? bMin
+  const hiIdx = bf.hi ?? bMax
+  let [a, b] = [Bidx[loIdx]!, Bidx[hiIdx]! + 1]
+  ;[a, b] = expandWords(raw, a, b)
+  ;[a, b] = expandFragments(raw, a, b)
+  const text = raw.slice(a, b)
+  const dollars = (text.match(/\$/g) ?? []).length
+  // ⚠️ **防御性代码：当前没有用例能区分它**（t4 评审 R-08 的变异 M19：关掉本行，全量套件 0 红、
+  // 真实 Dong 语料 0 差异；t7 又用「块里含字面 `$`（`the cost is $5 and the value $x_t$`，`$` 计数为奇数）」
+  // 试图触发，拒绝都发生在别的闸门（completedTail/no-match）之后）。
+  // 按构造即可论证：块内 `$` 计数恒偶（t1 实测），端点在片段内时 expandFragments 会把端点贴到
+  // 片段边界 ⇒ 跨度内含的片段必成对。保留它是纵深防御（`$` 是原子的，半公式比不还原更糟）。
+  if (dollars % 2 !== 0) return null
+
+  // ③ 覆盖门槛（绝对）：跨度必须解释选区的**每一个字母**。
+  //    数字/符号允许留在外面（公式编号 `(4)` 会以裸数字出现在选区里），字母不行：
+  //    选区里有字母而块里没有 ⇒ 本段不在候选块里（t3 报告 F2 的 `, while a learner encoder`）。
+  //    块侧不可能出现「跨度内部被吞掉的散文」：行走的块侧跳过只允许发生在 `$…$` 片段内（规则 ①），
+  //    所以内部多出来的块侧字符必然是 LaTeX 命令/括号，不是别人的句子。
+  let unpairedLetters = ''
+  for (let i = 0; i < S.length; i++) {
+    if (paired.has(i)) continue
+    if (p > 0 && i < p && bf.lo !== null) continue
+    if (q < S.length - 1 && i > q && bf.hi !== null) continue
+    if (/[a-z]/.test(S[i]!)) unpairedLetters += S[i]
+  }
+  // ④ 端点补词门槛：跨度末尾的词比**选区原文**末尾的词更长（expandWords 补了词尾）时，
+  //    选区原文必须带换行连字符 —— 否则就是「被别处的词接走」（`Instruction:` → `instructions`）。
+  let completedTail = ''
+  const selWord = trailingWordOf(chunkText)
+  if (selWord && b > 0 && WORD_CH.test(raw[b - 1]!)) {
+    let spanWord = ''
+    for (let k = b - 1; k >= 0 && WORD_CH.test(raw[k]!); k--) spanWord = raw[k]! + spanWord
+    if (spanWord.toLowerCase() !== selWord && !/[-\u2010\u2011\u2012\u2013\u2014\u2212]$/.test(chunkText.trimEnd())) {
+      completedTail = spanWord
+    }
+  }
+
+  const ratio = contentNormForRatio(text).length / S.length
+  const ok = ratio >= RATIO_LO && ratio <= RATIO_HI && unpairedLetters === '' && completedTail === ''
+  return { text, score: hit.score, ratio, ok, unpairedLetters, completedTail }
+}
+
+/** 候选择优规则（原型同款）：先 `ok`，再 `score`。 */
+function better(a: AlignCandidate | null, b: AlignCandidate | null): AlignCandidate | null {
+  if (!a) return b
+  if (!b) return a
+  if (b.ok !== a.ok) return b.ok ? b : a
+  return b.score > a.score ? b : a
+}
+
+export interface AlignResult {
+  /** 还原后的文本；对齐失败时**原样返回** chunkText（§3.4-9） */
+  text: string
+  applied: 0 | 1
+  score: number | null
+  ratio?: number
+  /** `|nf| < 4`：不对齐（§3.4-2） */
+  skipped: boolean
+  /** 拒绝原因（排障/测试用）：`short`=过短 / `no-match`=没有候选 / `gate`=绝对门槛没过 */
+  reason?: 'short' | 'no-match' | 'gate'
+  /** 诊断（测试与排障用）：选区侧未被解释的字母 / 端点补词越界 */
+  unpairedLetters?: string
+  completedTail?: string
+}
+
+/**
+ * 一行选区文本 ↔ 一个 MinerU text 块 → 还原后的文本。
+ * 纯函数；块文本在内部过一遍 `compactLatex`（幂等：块索引里已经是紧凑形态）。
+ *
+ * 交付侧语义（t6 修复后）：`applied=1` ⟺ 跨度覆盖了选区**每一个字母**、没有块侧多出来的散文、
+ * 长度比在 `[0.6,1.35]`、`score ≥ 0.75`。任一条不满足 ⇒ `applied=0` 且**原样返回** chunkText，
+ * 由 §3.8 的文案表如实提示（绝不静默换掉用户的句子）。
+ */
+export function alignSelectionToBlock(chunkText: string, blockText: string): AlignResult {
+  const { A: S } = normForAlign(chunkText)
+  if (S.length < MIN_NORM) return { text: chunkText, applied: 0, score: null, skipped: true, reason: 'short' }
+  const raw = compactLatex(blockText)
+  const { A: B, idx: Bidx } = normForAlign(raw)
+  if (!B.length) return { text: chunkText, applied: 0, score: null, skipped: false, reason: 'no-match' }
+  const inFrag = fragmentFlags(raw, Bidx)
+  let best: AlignCandidate | null = null
+  for (const hit of alignSeeds(S, B, inFrag)) {
+    best = better(best, candidateFor(S, raw, B, Bidx, inFrag, hit, chunkText))
+  }
+  if (!best || !best.ok || best.score < MIN_SCORE) {
+    return {
+      text: chunkText, applied: 0, skipped: false, reason: best ? 'gate' : 'no-match',
+      score: best ? best.score : null,
+      ...(best ? { ratio: best.ratio, unpairedLetters: best.unpairedLetters, completedTail: best.completedTail } : {}),
+    }
+  }
+  return { text: best.text, applied: 1, score: best.score, ratio: best.ratio, skipped: false, unpairedLetters: '', completedTail: '' }
+}
+
+/* ── 组装（§3.2 客户端切块 → §3.3/§3.4 服务端组装）─────────────────────── */
+
+export interface TranslateChunk {
+  page: number
+  kind: 'text' | 'formula'
+  text?: string
+  latex?: string
+}
+
+/**
+ * 从一个**已中和**的 piece 里按出现顺序抽出 `$…$` 片段 = 真公式（N-02）。
+ * 这里刻意不再做一次「看起来像 LaTeX」的过滤：唯一那道闸门是 `neutralizeNonLatexPairs`
+ * （它已把非 LaTeX 的成对 `$` 换成全角），再加一层过滤会变成**没有变异能区分的冗余代码**
+ * （t9 的 M-N02b/M-N02c 实测：删掉过滤，全部用例仍绿）。单一闸门 = 单一事实源。
+ */
+function latexFragments(s: string): string[] {
+  return [...s.matchAll(/\$[^$]*\$/g)].map((m) => m[0])
+}
+
+export interface AssembleResult {
+  /** 发给模型的源文本：公式已是单 `$` 定界的紧凑 LaTeX，乱码字符已被清洗 */
+  source: string
+  /** text chunk 数（用于 formulaStatus 判定） */
+  textChunkCount: number
+  /** 成功还原的 text chunk 数 */
+  applied: number
+  /** 因过短而未尝试对齐的 text chunk 数 */
+  skipped: number
+  /** 产物可读、行内还原有块可查（bare 产物也算 true） */
+  hasBlockIndex: boolean
+  /**
+   * **组装期统计的公式 token 列表**（N-02）：按组装顺序收集的、可以确信是真公式的 `$…$`——
+   * formula chunk 原样发的串 + 块跨度里**看起来是 LaTeX** 的片段。`verifyFormulas` 优先吃这个列表，
+   * 而不是回头解析最终字符串；正文里的成对字面 `$`（`$5 up to $`）既不入列表、也已被中和。
+   */
+  formulaTokens: string[]
+}
+
+/**
+ * 组装源文本（§3.3②/§3.4/§3.5）。
+ * - `formula` chunk → `$` + 紧凑 LaTeX + `$`（**该段乱码字符不进入请求体**）
+ * - `text` chunk → 在**该页所有候选块**里取最高分（跨块/跨页各自命中自己的页）
+ * - 页码变化处插一个 `\n`（§3.5 ④）
+ * - 清洗按 piece 分类做：`$…$` 内逐字保留 LaTeX，外面清文本层乱码（见 `stripJunk` 的说明）
+ *
+ * 行尾换行必须保留：客户端把换行作为 text 段的**结尾字符**发过来（§3.2-6），而替换用的块跨度
+ * 不含换行；不补回去，两行正文会被粘成一行（system 第 3 条要求保持行结构）。
+ */
+export function assembleSource(chunks: readonly TranslateChunk[], index: TextBlockIndex | null): AssembleResult {
+  const parts: string[] = []
+  const tokens: string[] = []
+  let textChunkCount = 0
+  let applied = 0
+  let skipped = 0
+  let lastPage: number | null = null
+  for (const c of chunks) {
+    if (lastPage !== null && c.page !== lastPage) parts.push('\n')
+    lastPage = c.page
+    if (c.kind === 'formula') {
+      const piece = '$' + (c.latex ?? '') + '$'
+      parts.push(piece)
+      tokens.push(piece)   // 客户端按 equation bbox 切出来的 ⇒ 一定是真公式
+      continue
+    }
+    textChunkCount++
+    const chunkText = c.text ?? ''
+    const eol = /[ \t]*\r?\n[ \t]*$/.test(chunkText) ? '\n' : ''
+    let best: AlignCandidate | null = null
+    let wasSkipped = false
+    for (const blk of index?.blocks ?? []) {
+      if (blk.page !== c.page) continue
+      const r = alignSelectionToBlock(chunkText, blk.text)
+      if (r.skipped) {
+        wasSkipped = true
+        continue
+      }
+      best = better(best, r.applied === 1
+        ? { text: r.text + eol, score: r.score ?? 0, ratio: r.ratio ?? 1, ok: true, unpairedLetters: '', completedTail: '' }
+        : null)
+    }
+    if (wasSkipped) skipped++
+    if (best) {
+      applied++
+      // 块跨度：里面的 `$…$` 是块文本的 LaTeX 片段；但块正文里也可能印了**字面** `$`（`$5 up to $`）。
+      // 只保留「看起来是 LaTeX」的片段，其余 `$` 中和成全角（N-02）；token 在**组装期**收集。
+      const span = neutralizeNonLatexPairs(best.text)
+      parts.push(span)
+      for (const frag of latexFragments(span)) tokens.push(frag)
+    } else {
+      // 未对齐 → 这段就是文本层原文，里面的 `$` 只可能是**字面字符**（`$5` 之类），
+      // 不是定界符。必须中和掉：否则它会与别处的 `$` 配成假片段，
+      // 让 `formulaTokens`/`verifyFormulas` 把真公式漏掉（R-03 实测：源 `cost is $5 and $x_t$`
+      // 只识别出一个 token `$5 and $`，`$x_t$` 丢失时 formulaLost 仍为 0 ⇒ A7 失效）。
+      parts.push(neutralizeDollars(chunkText))
+    }
+  }
+  return {
+    source: collapse(parts.map(cleanPiece).join('')),
+    textChunkCount,
+    applied,
+    skipped,
+    hasBlockIndex: index?.source === 'mineru',
+    formulaTokens: tokens,
+  }
+}
+
+/** `formulaStatus` 判定（§3.9 表）。 */
+export function formulaStatusOf(r: Pick<AssembleResult, 'hasBlockIndex' | 'applied' | 'textChunkCount'>): string {
+  if (!r.hasBlockIndex) return 'no-artifact'
+  if (r.textChunkCount === 0) return 'applied'
+  if (r.applied === 0) return 'unavailable'
+  if (r.applied < r.textChunkCount) return 'partial'
+  return 'applied'
+}
+
+/* ── 提示词与请求体（§3.6）────────────────────────────────────────────── */
+
+export function clampMaxTokens(chars: number): number {
+  return Math.min(4096, Math.max(256, Math.ceil(1.5 * chars)))
+}
+
+/** 推理型模型关思考（与 src/translate.ts:264 同一判据、同一理由：自定义端点不加）。 */
+export function wantsThinkingOff(baseUrl: string): boolean {
+  return /bigmodel|kimi|moonshot|deepseek/i.test(baseUrl)
+}
+
+/** 请求体：**只有** model/messages/max_tokens/temperature（命中域名时才多 thinking）。 */
+export function buildRequestBody(model: string, source: string, baseUrl = ''): Record<string, unknown> {
+  const body: Record<string, unknown> = {
+    model,
+    messages: [
+      { role: 'system', content: SELECTION_SYSTEM_PROMPT },
+      { role: 'user', content: source },
+    ],
+    max_tokens: clampMaxTokens(source.length),
+    temperature: 0,
+  }
+  if (wantsThinkingOff(baseUrl)) body['thinking'] = { type: 'disabled' }
+  return body
+}
+
+/* ── 响应清洗与公式保全校验（§3.6-2/3/4）──────────────────────────────── */
+
+/** 整体被 ``` 包裹时剥掉围栏与语言标注。 */
+export function stripFence(s: string): string {
+  const t = s.trim()
+  const m = /^```[A-Za-z0-9_+-]*[ \t]*\r?\n([\s\S]*?)\r?\n?```$/.exec(t)
+  return m ? m[1]!.trim() : t
+}
+
+/** 剥掉行首的 `译文：` / `翻译：` / `Translation:`。 */
+export function stripPrefix(s: string): string {
+  return s.replace(/^\s*(?:译文|翻译|Translation)\s*[:：]\s*/, '')
+}
+
+/**
+ * 源文本里的 `$…$` token（按出现顺序）。
+ * **权威来源是 `assembleSource` 在组装期收集的 `formulaTokens` 列表**（N-02）——组装文本里的
+ * 每个 `$…$` 都在组装期过了唯一那道闸门（`neutralizeNonLatexPairs`：字面 `$` 中和为全角），
+ * 所以这里再解析一遍得到的列表与那个列表**逐项相同**（测试 `N-02` 直接断言这条等价性）。
+ * 保留本函数是为了兼容「只拿到源文本」的调用方（如 host 路由，不在本轮 inScope）与单测。
+ */
+export function formulaTokens(source: string): string[] {
+  return [...source.matchAll(/\$[^$]*\$/g)].map((m) => m[0])
+}
+
+export interface FormulaVerify {
+  total: number
+  kept: number
+  lost: number
+  missing: string[]
+}
+
+/** 逐 token 原样 `includes` 校验（§3.6-4）。v1 不做自动回插，只回报缺失数。 */
+export function verifyFormulas(source: string, translation: string, tokens?: readonly string[]): FormulaVerify {
+  // tokens 优先：调用方（路由/组装方）应传 `assembleSource(...).formulaTokens`，避免回头解析字符串
+  const list = tokens ?? formulaTokens(source)
+  const missing = list.filter((t) => !translation.includes(t))
+  return { total: list.length, kept: list.length - missing.length, lost: missing.length, missing }
+}
+
+/* ── 缓存（§3.7④）：进程内存 LRU，不落盘 ───────────────────────────────── */
+
+/** 键 = `sha256(model + '\0' + assembledText)`；**不含 key**（不做任何密钥派生）。 */
+export function selectionCacheKey(model: string, source: string): string {
+  return createHash('sha256').update(model + '\0' + source, 'utf8').digest('hex')
+}
+
+/** 极简 LRU：Map 的插入序即最近使用序（命中先删再插）。零依赖。 */
+export class TranslateSelectionCache {
+  private map = new Map<string, string>()
+
+  constructor(private readonly limit: number = CACHE_LIMIT) {}
+
+  get(key: string): string | undefined {
+    const hit = this.map.get(key)
+    if (hit === undefined) return undefined
+    this.map.delete(key)
+    this.map.set(key, hit)
+    return hit
+  }
+
+  set(key: string, value: string): void {
+    if (this.map.has(key)) this.map.delete(key)
+    this.map.set(key, value)
+    while (this.map.size > this.limit) {
+      const oldest = this.map.keys().next().value
+      if (oldest === undefined) break
+      this.map.delete(oldest)
+    }
+  }
+
+  get size(): number { return this.map.size }
+
+  clear(): void { this.map.clear() }
+}
+
+/** 进程级默认缓存（服务端路由用它；测试可注入自己的实例）。 */
+export const selectionCache = new TranslateSelectionCache()
+
+/* ── 端点调用（§3.6 / §3.7）──────────────────────────────────────────── */
+
+export type FetchLike = (url: string, init: Record<string, unknown>) => Promise<Response>
+
+export interface TranslateSelectionDeps {
+  fetchImpl?: FetchLike
+  timeoutMs?: number
+  cache?: TranslateSelectionCache
+  /** 便于测试与排障留痕；默认 no-op，只打印白名单字段 */
+  log?: (info: { model: string; status: number; ms: number; chars: number }) => void
+}
+
+export interface TranslateSelectionResult {
+  translation: string
+  model: string
+  cached: boolean
+  ms: number
+  formulaTotal: number
+  formulaKept: number
+  formulaLost: number
+}
+
+function networkDetail(err: unknown): string {
+  const cause = err instanceof Error && err.cause instanceof Error ? `: ${err.cause.message}` : ''
+  return (err instanceof Error ? err.message : String(err)) + cause
+}
+
+/**
+ * 调端点翻译一段源文本。
+ * - body/URL/头与 §3.6 写死一致；**不**发 response_format/reasoning/tools/top_p/stream
+ * - 唯一的重试：HTTP 400 且响应体匹配 `/temperature/i` → 去掉 `temperature` 重发一次
+ * - 上游错误详情一律过 `sanitizeDetail(text, apiKey)`；本函数不打印任何 key
+ */
+export async function translateSelection(
+  endpoint: TranslateEndpoint,
+  source: string,
+  deps: TranslateSelectionDeps = {},
+): Promise<TranslateSelectionResult> {
+  const baseUrl = endpoint.baseUrl ?? ''
+  const apiKey = endpoint.apiKey ?? ''
+  const model = endpoint.model ?? ''
+  if (!baseUrl || !apiKey || !model) {
+    throw new SelectionTranslateError('no-endpoint', 503, '未配置翻译端点：在阅读器里点 ⚙ 填写（OpenAI 兼容端点即可）')
+  }
+  const cache = deps.cache ?? selectionCache
+  const key = selectionCacheKey(model, source)
+  const hit = cache.get(key)
+  if (hit !== undefined) {
+    const v = verifyFormulas(source, hit)
+    return { translation: hit, model, cached: true, ms: 0, formulaTotal: v.total, formulaKept: v.kept, formulaLost: v.lost }
+  }
+
+  const fetchImpl = (deps.fetchImpl ?? (globalThis.fetch as FetchLike))
+  const url = baseUrl.replace(/\/+$/, '') + '/chat/completions'
+  const headers = { 'content-type': 'application/json', authorization: `Bearer ${apiKey}` }
+  const started = Date.now()
+  const send = async (body: Record<string, unknown>): Promise<Response> => {
+    try {
+      return await fetchImpl(url, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(body),
+        signal: AbortSignal.timeout(deps.timeoutMs ?? UPSTREAM_TIMEOUT_MS),
+      })
+    } catch (err) {
+      // 超时 vs 连不上：两者文案不同（§3.7②）
+      const name = err instanceof Error ? err.name : ''
+      if (name === 'TimeoutError' || name === 'AbortError') {
+        throw new SelectionTranslateError('timeout', 504, '翻译超时，请重试')
+      }
+      // 网络异常文本同样必须过 sanitizeDetail（R-04）：fetch 抛出的原因串可能带上
+      // baseUrl（含凭据/查询参数）或回显 Authorization，而这条消息会原样进响应体到前端。
+      throw new SelectionTranslateError('network', 502, `无法连接端点：${sanitizeDetail(networkDetail(err), apiKey)}`)
+    }
+  }
+
+  let res = await send(buildRequestBody(model, source, baseUrl))
+  let resText: string | null = null
+  if (res.status === 400) {
+    const probe = await res.text().catch(() => '')
+    // 唯一的白名单重试：严格端点不认 temperature
+    if (/temperature/i.test(probe)) {
+      const body = buildRequestBody(model, source, baseUrl)
+      delete body['temperature']
+      res = await send(body)
+    } else {
+      resText = probe
+    }
+  }
+  if (!res.ok) {
+    const text = (resText ?? await res.text().catch(() => '')).slice(0, 200)
+    throw new SelectionTranslateError(
+      'upstream', 502,
+      `上游返回 HTTP ${res.status}${text ? '：' + sanitizeDetail(text, apiKey) : ''}`,
+      res.status,
+    )
+  }
+  const rawText = resText ?? await res.text().catch(() => '')
+  let data: unknown
+  try {
+    data = JSON.parse(rawText)
+  } catch {
+    throw new SelectionTranslateError('upstream', 502, `端点响应不是合法 JSON：${sanitizeDetail(rawText.slice(0, 200), apiKey)}`, res.status)
+  }
+  const content = (data as { choices?: Array<{ message?: { content?: unknown } }> })?.choices?.[0]?.message?.content
+  if (typeof content !== 'string' || content.trim() === '') {
+    throw new SelectionTranslateError('upstream', 502, '端点没有返回补全内容（choices[0].message.content 为空）', res.status)
+  }
+  const translation = stripPrefix(stripFence(content))
+  const ms = Date.now() - started
+  cache.set(key, translation)
+  const v = verifyFormulas(source, translation)
+  // 日志白名单：只有 model/status/ms/chars（§3.7③）——key 与 baseUrl 永不出现
+  const log = deps.log ?? ((info) => console.log('[dsh-paper-reader] translate-selection', JSON.stringify(info)))
+  log({ model, status: 200, ms, chars: source.length })
+  return { translation, model, cached: false, ms, formulaTotal: v.total, formulaKept: v.kept, formulaLost: v.lost }
+}
diff --git a/test/fs-probe.mjs b/test/fs-probe.mjs
index 28b4e6e..1b8ffc9 100644
--- a/test/fs-probe.mjs
+++ b/test/fs-probe.mjs
@@ -7,11 +7,12 @@
 //     契约是 500 trash-move-failed；Windows EPERM → 契约是 409 file-busy 的占用语义）。
 // 所以这里全都实测一次，结果按目录缓存。
 
-import { existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs'
+import { chmodSync, existsSync, mkdirSync, mkdtempSync, renameSync, rmSync, writeFileSync } from 'node:fs'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 
 const caseCache = new Map()
+let chmodCache
 let renameErrnoCache
 
 /**
@@ -76,3 +77,49 @@ export function isTrashRelPath(p) {
   const segs = p.split(/[\\/]/)
   return segs.length >= 2 && segs[0] === '.trash' && segs.every((x) => x.length > 0)
 }
+
+/**
+ * 实测「把目录设为只读（chmod 0o555）之后，里面的文件还能不能被 rename 走」。
+ *   · POSIX（ext4/APFS）：不能 → 可用于「回收站移动失败」的注入；
+ *   · Windows：chmod 只映射「只读位」，不阻止 rename → 不能。
+ * 调用方据此选注入方式（而不是硬编码平台）。
+ */
+export function chmodBlocksRename(dir = tmpdir()) {
+  if (chmodCache !== undefined) return chmodCache
+  const d = mkdtempSync(join(dir, 'dpr-chmodprobe-'))
+  try {
+    const sub = join(d, 'sub')
+    mkdirSync(sub)
+    writeFileSync(join(sub, 'f.txt'), 'x')
+    chmodSync(sub, 0o555)
+    try {
+      renameSync(join(sub, 'f.txt'), join(d, 'moved.txt'))
+      chmodCache = false
+    } catch {
+      chmodCache = true
+    } finally {
+      try { chmodSync(sub, 0o755) } catch { /* 已不可改也无需恢复 */ }
+    }
+  } finally {
+    rmSync(d, { recursive: true, force: true })
+  }
+  return chmodCache
+}
+
+/**
+ * 实测「当前文件系统能否把 0x00-0x1F 控制字符放进文件名」。
+ *   · Win32 路径层禁止 → false（历史遗留的控制字符名在那类平台根本造不出来）；
+ *   · POSIX → true。
+ * 探针建在给定目录的**子目录**里并即时清理，不留残留。
+ */
+export function canStoreControlName(dir = tmpdir()) {
+  const probe = mkdtempSync(join(dir, 'dpr-ctrlprobe-'))
+  try {
+    mkdirSync(join(probe, 'weird\u0001name'))
+    return true
+  } catch {
+    return false
+  } finally {
+    rmSync(probe, { recursive: true, force: true })
+  }
+}
diff --git a/test/katex-bubble-render.test.mjs b/test/katex-bubble-render.test.mjs
new file mode 100644
index 0000000..ffb74c2
--- /dev/null
+++ b/test/katex-bubble-render.test.mjs
@@ -0,0 +1,359 @@
+// test/katex-bubble-render.test.mjs — 划词译文气泡里的**公式渲染**（vendored KaTeX，离线）
+//
+// 被钉住的契约（docs 之外由本文件独立构造证据）：
+//   1. 译文里的 `$…$` / `$$…$$` 必须**真的渲染成数学**（真实 KaTeX，不是打桩），其余文字仍走 textContent；
+//   2. **绝不 innerHTML 模型输出**：渲染路径只允许 textContent + KaTeX 自建 DOM（用例直接数 innerHTML 写入次数）；
+//   3. 渲染失败必须**降级**：该段退回原始 LaTeX 文本，并在 #tr-note 如实提示第几个失败（绝不留白）；
+//   4. 气泡既有契约不变：内部零 button、#tr-note 仍是纯文本。
+//
+// 独立构造证据：本文件自带最小 DOM stub（不复用别的测试文件的 harness），真实 KaTeX 从
+// reader/vendor/katex.min.js 现场加载 —— 与浏览器同一个文件、同一套参数。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import vm from 'node:vm'
+import { extractModuleScript } from './reader-script.mjs'
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..')
+const KATEX_JS = join(REPO, 'reader', 'vendor', 'katex.min.js')
+const KATEX_CSS = join(REPO, 'reader', 'vendor', 'katex.min.css')
+
+/** 真实 vendored KaTeX：它要在**同一个** vm 上下文里拿 document 建节点，故每次 harness 绑定当次 doc。 */
+const KCTX = (() => {
+  const c = { console, setTimeout, clearTimeout }
+  c.globalThis = c; c.window = c; c.self = c
+  vm.createContext(c)
+  vm.runInContext(readFileSync(KATEX_JS, 'utf8'), c)
+  return c
+})()
+
+/** 最小 DOM stub：够 KaTeX.render（createElement/createElementNS/createTextNode + compatMode）与
+ *  本功能（textContent/appendChild/classList）用；**innerHTML 写入会被记数**（契约 2 的证据）。 */
+function makeEl(tag = 'div') {
+  const el = {
+    tagName: String(tag).toUpperCase(), nodeType: 1, id: '', dataset: {}, children: [], childNodes: [],
+    _classes: new Set(), _handlers: {}, _innerHTMLWrites: 0, _text: '',
+    style: { setProperty(k, v) { this[k] = v }, removeProperty(k) { delete this[k] }, getPropertyValue: (k) => el.style[k] ?? '' },
+    classList: {
+      add: (...c) => c.forEach((x) => el._classes.add(x)),
+      remove: (...c) => c.forEach((x) => el._classes.delete(x)),
+      contains: (c) => el._classes.has(c),
+      toggle: (c, on) => (on ? el._classes.add(c) : el._classes.delete(c)),
+    },
+    // DocumentFragment（nodeType 11）在 appendChild 时要**展平**（真实 DOM 语义；KaTeX 用它建子树）
+    appendChild(c) {
+      if (c && c.nodeType === 11) { for (const k of c.children.slice()) el.appendChild(k); c.children = []; return c }
+      el.children.push(c); el.childNodes.push(c); c.parentNode = el; c.parentElement = el; return c
+    },
+    append(...cs) { cs.forEach((c) => el.appendChild(c)) },
+    insertBefore(c) { return el.appendChild(c) },
+    removeChild(c) { el.children = el.children.filter((x) => x !== c); return c },
+    remove() { const p = el.parentNode; if (p) p.children = p.children.filter((x) => x !== el) },
+    setAttribute() {}, getAttribute() { return null }, removeAttribute() {},
+    focus() {}, blur() {}, select() {}, click() { if (typeof el.onclick === 'function') el.onclick() },
+    addEventListener(t, h) { (el._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (el._handlers[t]) el._handlers[t] = el._handlers[t].filter((x) => x !== h) },
+    dispatchEvent() { return true },
+    querySelector() { return null }, querySelectorAll() { return [] },
+    closest() { return null }, contains() { return false }, scrollIntoView() {},
+    getBoundingClientRect() { return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 } },
+    getContext() { return {} }, clientHeight: 0, clientWidth: 0, scrollTop: 0, scrollHeight: 0, offsetTop: 0, offsetHeight: 0,
+  }
+  // textContent：读 = 自身文本 + 全部后代文本（真实 DOM 语义）；写 = 先清空子节点
+  Object.defineProperty(el, 'textContent', {
+    get: () => (el.children.length ? el.children.map((c) => c.textContent ?? '').join('') : el._text),
+    set: (v) => { el.children = []; el.childNodes = []; el._text = v == null ? '' : String(v) },
+  })
+  Object.defineProperty(el, 'className', {
+    get: () => [...el._classes].join(' '),
+    set: (v) => { el._classes = new Set(String(v || '').split(/\s+/).filter(Boolean)) },
+  })
+  let inner = ''
+  Object.defineProperty(el, 'innerHTML', {
+    get: () => inner,
+    set: (v) => { inner = v; el._innerHTMLWrites += 1; if (v === '') { el.children = []; el.childNodes = [] } },
+  })
+  Object.defineProperty(el, 'firstChild', { get: () => el.children[0] ?? null })
+  Object.defineProperty(el, 'parentNode', { get: () => el._parent ?? null, set: (v) => { el._parent = v } })
+  return el
+}
+
+function makeDoc() {
+  const els = new Map()
+  const named = makeEl('div')
+  const created = []
+  const doc = {
+    compatMode: 'CSS1Compat',           // KaTeX 在 quirks 模式拒绝渲染
+    documentElement: makeEl('html'),
+    createElement(tag) { const e = makeEl(tag); created.push(e); return e },
+    createElementNS(_ns, tag) { const e = makeEl(tag); created.push(e); return e },
+    createTextNode(t) { const n = makeEl('#text'); n.nodeType = 3; n.textContent = t; return n },
+    createDocumentFragment() { const f = makeEl('#document-fragment'); f.nodeType = 11; return f },
+    getElementById(id) { if (!els.has(id)) { const e = makeEl('div'); e.id = id; named.appendChild(e); els.set(id, e) } return els.get(id) },
+    querySelector() { return null },
+    querySelectorAll() { return [] },
+    addEventListener() {}, removeEventListener() {},
+  }
+  return { doc, els, created, named }
+}
+
+/** 载入真实 reader 脚本（同 window.katex = 真实 KaTeX），返回可徒手调用的渲染入口。 */
+function loadReader({ katex } = {}) {
+  const { doc, els, created } = makeDoc()
+  KCTX.document = doc
+  const win = {
+    katex: katex === undefined ? KCTX.katex : katex,
+    innerWidth: 1200, innerHeight: 900, addEventListener() {}, getSelection: () => null,
+    matchMedia: () => ({ addEventListener() {}, removeEventListener() {} }),
+  }
+  const ctx = {
+    document: doc, window: win, navigator: {}, location: { search: '' }, matchMedia: win.matchMedia,
+    localStorage: { getItem: () => null, setItem() {}, removeItem() {} },
+    setTimeout, clearTimeout, setInterval: () => 0, clearInterval() {}, AbortController, console,
+    URLSearchParams, Promise, Math, JSON, Object, Array, Number, String, Boolean, Error, RegExp, Date, Set, Map,
+    IntersectionObserver: class { observe() {} unobserve() {} disconnect() {} takeRecords() { return [] } },
+    pdfjsLib: { TextLayer: class { async render() {} }, GlobalWorkerOptions: {} },
+    fetch: async () => ({ ok: true, status: 200, json: async () => ({ hasTranscript: false, pageCount: 0, pdfPath: '' }) }),
+  }
+  ctx.globalThis = ctx
+  vm.createContext(ctx)
+  const harness = `;globalThis.__t = { splitTranslatedMath, trRenderBody, trComposeNote, showTrPop };`
+  vm.runInContext(extractModuleScript(readFileSync(join(REPO, 'reader', 'index.html'), 'utf8'), { where: 'reader/index.html' }) + harness, ctx, { filename: 'reader-inline.js' })
+  return { t: ctx.__t, doc, els, created, win }
+}
+
+/** 本机 Dong 那篇（Language-Conditioned World Modeling for Visual Navigation）MinerU 产物里
+ *  **全部 18 个 equation 块**的原始 text（含 MinerU 自带的 $$…$$ 外壳），逐字取自该论文的 .mineru.json。 */
+const DONG_EQUATIONS = [
+  "$$\n\\begin{array} { r } { s _ { i } = \\mathrm { E n c } _ { \\theta } \\left( o _ { i } \\right) \\quad \\hat { s } _ { t + 1 } \\sim F _ { \\theta } \\left( \\hat { s } _ { t + 1 } ~ | ~ \\hat { \\mathbf { s } } _ { t } , \\hat { a } _ { t } , I , t _ { s } \\right) , } \\end{array}\\tag{1}\n$$",
+  "$$\n\\hat { s } _ { t - m } ^ { ( \\ell _ { m } ) } = \\sqrt { \\alpha \\ell _ { m } } \\hat { s } _ { t - m } + \\sqrt { 1 - \\alpha _ { \\ell _ { m } } } \\epsilon _ { m } ,\\tag{2}\n$$",
+  "$$\n\\mathcal { L } _ { \\mathrm { K L } } = D _ { \\mathrm { K L } } \\Big ( q _ { \\mathrm { e x p e r t } } ( z _ { \\mathrm { e x p e r t } } \\mid s _ { t : n } , I _ { c l i p } )\n$$",
+  "$$\n\\parallel q _ { \\mathrm { l e a r n e r } } ( z _ { \\mathrm { p l a n } } \\mid s _ { t } , I _ { c l i p } ) \\biggl ) ,\\tag{3}\n$$",
+  "$$\n\\begin{array} { r } { \\hat { s } _ { t + 1 } ^ { \\pi } \\sim F _ { \\theta } ( \\hat { s } _ { t + 1 } ^ { \\pi } \\mid \\mathbf { s } _ { t } , \\hat { a } _ { t } , I _ { c l i p } , t _ { s } ) , } \\end{array}\\tag{4}\n$$",
+  "$$\nr _ { t } ^ { \\mathrm { i n t } } ( s _ { t + 1 } ^ { E } , \\hat { s } _ { t + 1 } ^ { \\pi } ) = \\frac { s _ { t + 1 } ^ { E } \\cdot \\hat { s } _ { t + 1 } ^ { \\pi } } { \\operatorname* { m a x } ( \\lVert s _ { t + 1 } ^ { E } \\rVert , \\lVert \\hat { s } _ { t + 1 } ^ { \\pi } \\rVert ) ^ { 2 } } \\mathrm { ~ , ~ }\\tag{5}\n$$",
+  "$$\nv _ { \\psi } ( s _ { t } , I _ { c l i p } , z _ { \\mathrm { p l a n } } ) \\approx \\mathbb { E } _ { \\pi _ { \\theta } , p _ { \\phi } } \\left[ \\sum _ { k = t } ^ { t + H - 1 } \\gamma ^ { k - t } r _ { k } ^ { \\mathrm { i n t } } \\right] ,\\tag{6}\n$$",
+  "$$\n\\mathcal { L } ( \\psi ) = \\mathbb { E } _ { \\pi _ { \\theta } , p _ { \\phi } } \\left[ \\sum _ { k = t } ^ { t + H - 1 } \\frac { 1 } { 2 } \\big ( v _ { \\psi } \\big ( \\hat { s } _ { k } , I _ { c l i p } , z _ { \\mathrm { p l a n } } \\big ) - \\mathrm { s g } ( V _ { k } ^ { \\lambda } ) \\big ) ^ { 2 } \\right] ,\\tag{7}\n$$",
+  "$$\n\\mathcal { L } ( \\theta ) = \\mathbb { E } _ { \\pi _ { \\theta } , p _ { \\phi } } \\left[ \\sum _ { k = t } ^ { t + H - 1 } \\left( - V _ { k } ^ { \\lambda } + \\alpha _ { 1 } \\mathcal { L } _ { \\mathrm { K L } } ^ { k } + \\alpha _ { 2 } \\mathcal { L } _ { \\mathrm { i n s } } ^ { k } \\right) \\right] .\\tag{8}\n$$",
+  "$$\n\\hat { a } _ { t + 1 } \\sim \\pi _ { \\theta } \\big ( \\hat { a } _ { t + 1 } \\mid s _ { t + 1 } , I _ { c l i p } , z _ { \\mathrm { p l a n } } \\big ) \\ .\\tag{9}\n$$",
+  "$$\n\\begin{array} { r } { \\big ( \\hat { a } _ { t + 1 } , \\hat { o } _ { t + 1 } \\big ) \\ : = \\ : G _ { \\theta } \\big ( \\hat { o } _ { t } , \\hat { a } _ { t } , I , o _ { s } \\big ) , } \\end{array}\\tag{10}\n$$",
+  "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { j o i n t } } = \\mathcal { L } _ { \\mathrm { p l a n } } + \\lambda \\mathcal { L } _ { \\mathrm { i m a g i n e } } , } \\end{array}\\tag{11}\n$$",
+  "$$\n\\begin{array} { r } { \\mathcal { L } _ { \\mathrm { j o i n t } } = \\mathcal { L } _ { \\mathrm { p l a n } } + \\lambda \\mathcal { L } _ { \\mathrm { i m a g i n e } } , } \\end{array}\\tag{A1}\n$$",
+  "$$\n\\mathcal { L } _ { \\mathrm { p l a n } } = \\frac { 1 } { 3 } { \\sum } _ { d \\in \\{ x , y , \\phi \\} } \\Bigl ( - \\log P ( b _ { d } ^ { * } | s _ { j } \\in \\mathcal { B } _ { d } ) \\Bigr ) + \\mathcal { L } _ { \\mathrm { t e x t } } ,\\tag{A2}\n$$",
+  "$$\n\\boldsymbol { \\mathcal { L } } _ { \\mathrm { i m a g i n e } } = \\frac { 1 } { m } \\sum _ { j = 1 } ^ { m } \\sum _ { k = 1 } ^ { K } \\lVert \\mathbf { u } _ { j } - \\mathbf { c } _ { k } \\rVert ^ { 2 } \\boldsymbol { \\cdot } P ( s _ { j } = \\mathbf { c } _ { k } ) , ( \\mathrm { A 3 } )\n$$",
+  "$$\n\\mathrm { S R } = \\frac { 1 } { N } \\sum _ { i = 1 } ^ { N } \\mathbf { 1 } \\Big [ d \\Big ( \\hat { p } _ { T } ^ { ( i ) } , p _ { g } ^ { ( i ) } \\Big ) < \\bar { s } \\Big ] .\\tag{A4}\n$$",
+  "$$\n\\mathrm { S S I M @ } n = \\mathrm { S S I M } \\big ( o _ { t + n } , \\hat { o } _ { t + n } ^ { ( n ) } \\big ) ,\\tag{A5}\n$$",
+  "$$\n\\operatorname { D r e a m S i m } ( I _ { 1 : N } , T ) { = } \\frac { 1 } { N } { \\sum _ { i = 1 } ^ { N } } \\frac { \\langle f _ { \\mathrm { i m g } } ( I _ { i } ) , f _ { \\mathrm { t e x t } } ( T ) \\rangle } { \\left\\| f _ { \\mathrm { i m g } } ( I _ { i } ) \\right\\| \\cdot \\left\\| f _ { \\mathrm { t e x t } } ( T ) \\right\\| }  .\\tag{A6}\n$$",
+]
+
+test('K1 真实 KaTeX 跑通论文里全部 18 个 equation（$$…$$ 独立成行）', () => {
+  assert.equal(DONG_EQUATIONS.length, 18, '夹具必须是那篇论文的全部 18 个 equation')
+  const R = loadReader()
+  const before = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  DONG_EQUATIONS.forEach((raw, i) => {
+    const failed = R.t.trRenderBody(raw)
+    assert.deepEqual([...failed], [], `第 ${i + 1} 个 equation 渲染失败：${raw.slice(0, 80)}`)
+    const segs = R.els.get('tr-body').children
+    assert.equal(segs.length, 1, `第 ${i + 1} 个 equation 应该正好一段（display 公式）`)
+    assert.ok(segs[0]._classes.has('tr-math-block'), `第 ${i + 1} 个 equation 必须是块级数学段`)
+    assert.ok(segs[0].children.length > 0, `第 ${i + 1} 个 equation 渲染后不得留白（空元素）`)
+    const rendered = segs[0].children.map((c) => String(c.className)).join(' ')
+    assert.ok(/katex/.test(rendered), `第 ${i + 1} 个 equation 必须产出 KaTeX DOM：${rendered.slice(0, 60)}`)
+  })
+  const after = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  assert.equal(after - before, 0, '渲染 18 个公式期间绝不允许写 innerHTML')
+})
+
+test('K2 切段器：行内/独立/多行/转义美元号/未闭合/空公式', () => {
+  const R = loadReader()
+  const sp = (x) => JSON.parse(JSON.stringify(R.t.splitTranslatedMath(x)))   // 跨 realm 归一
+  assert.deepEqual(sp('纯文字'), [{ kind: 'text', text: '纯文字' }])
+  // 行内
+  assert.deepEqual(sp('a $x_t$ b'), [
+    { kind: 'text', text: 'a ' }, { kind: 'math', text: 'x_t', display: false, delim: '$' }, { kind: 'text', text: ' b' }])
+  // 独立成行（含换行）
+  assert.deepEqual(sp('前\n$$\n\\frac{1}{2}\n$$\n后'), [
+    { kind: 'text', text: '前\n' }, { kind: 'math', text: '\n\\frac{1}{2}\n', display: true, delim: '$$' }, { kind: 'text', text: '\n后' }])
+  // 字面美元号 \$ 不是定界符
+  assert.deepEqual(sp('价格 \\$5 与 $x$'), [
+    { kind: 'text', text: '价格 $5 与 ' }, { kind: 'math', text: 'x', display: false, delim: '$' }])
+  // \(…\) 行内 / \[…\] 独立成行（模型/上游有时给这套定界符 —— pr7 诊断 P2）
+  assert.deepEqual(sp('设 \\(x_t\\) 为状态'), [
+    { kind: 'text', text: '设 ' }, { kind: 'math', text: 'x_t', display: false, delim: '\\)' }, { kind: 'text', text: ' 为状态' }])
+  assert.deepEqual(sp('如下 \\[ \\frac{a}{b} \\] 所示'), [
+    { kind: 'text', text: '如下 ' }, { kind: 'math', text: ' \\frac{a}{b} ', display: true, delim: '\\]' }, { kind: 'text', text: ' 所示' }])
+  // 未闭合 / 空公式 / 不像数学 ⇒ 当普通文本，绝不产生「半个公式」
+  assert.deepEqual(sp('a $x'), [{ kind: 'text', text: 'a $x' }])
+  assert.deepEqual(sp('a $$b'), [{ kind: 'text', text: 'a $$b' }])
+  assert.deepEqual(sp('a $$ $$ b'), [{ kind: 'text', text: 'a $$ $$ b' }])
+  assert.deepEqual(sp('未闭合 \\(x_t'), [{ kind: 'text', text: '未闭合 \\(x_t' }])
+  // 行内公式不跨行（避免把整段散文吞进公式）
+  assert.deepEqual(sp('$a\nb$'), [{ kind: 'text', text: '$a\nb$' }])
+})
+
+test('K3 降级：非法 LaTeX 必须显示原始 LaTeX + #tr-note 如实提示（绝不留白）', () => {
+  const R = loadReader()
+  const note = R.t.trComposeNote('', R.t.trRenderBody('前 $\\frac{1}{$ 后'))
+  assert.deepEqual([...R.t.trRenderBody('前 $\\frac{1}{$ 后')], [1], '非法公式必须被计入失败序号')
+  const segs = R.els.get('tr-body').children
+  assert.equal(segs.length, 3, '文本/公式/文本 三段都要在，绝不整段消失')
+  assert.ok(segs[1]._classes.has('tr-math-fallback'), '失败段必须打上降级标记')
+  assert.equal(segs[1].textContent, '$\\frac{1}{$', '失败段必须显示**原始 LaTeX**（可读可复制）')
+  assert.ok(segs[1].textContent.trim().length > 0, '失败段不得空白')
+  assert.equal(segs[0].textContent, '前 ')
+  assert.equal(segs[2].textContent, ' 后')
+  assert.match(note, /第 1 个公式未能渲染/, `提示必须点名第几个公式：${note}`)
+})
+
+test('K3b 混合：只有失败的那个被点名，其余照常渲染（不是整块降级）', () => {
+  const R = loadReader()
+  const failed = [...R.t.trRenderBody('$a$ 然后 $\\notacommand{$ 再 $b^2$')]
+  assert.deepEqual(failed, [2], '只允许第 2 个公式失败')
+  const segs = R.els.get('tr-body').children
+  const math = segs.filter((e) => e._classes.has('tr-math'))
+  assert.equal(math.length, 3)
+  assert.ok(!math[0]._classes.has('tr-math-fallback'), '第 1 个公式必须渲染成功')
+  assert.ok(math[1]._classes.has('tr-math-fallback'), '第 2 个公式必须降级')
+  assert.ok(!math[2]._classes.has('tr-math-fallback'), '第 3 个公式必须渲染成功')
+  const note = R.t.trComposeNote('公式未原样保留', failed)
+  assert.match(note, /^公式未原样保留 第 2 个公式未能渲染/, `既有提示要保留、渲染失败要追加：${note}`)
+})
+
+test('K4 渲染参数契约 + 绝不 innerHTML（真实 KaTeX 与打桩两路都查）', () => {
+  // ① 真实 KaTeX：渲染期间 innerHTML 写入次数必须为 0
+  const R = loadReader()
+  const before = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  R.t.trRenderBody('译文 $x_t$ 与 $$\\mathbf{1}[d]$ 结束')
+  const after = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  assert.equal(after - before, 0, '真实 KaTeX 路径也不许写 innerHTML')
+
+  // ② 打桩 KaTeX：核对三个契约参数，并证明 LaTeX 是**作为文本参数**交给渲染器的
+  const calls = []
+  const fake = {
+    renderToString(tex, opts) { calls.push({ fn: 'renderToString', tex, opts }); return '<span class="katex"></span>' },
+    render(tex, el, opts) { calls.push({ fn: 'render', tex, el, opts }); el.appendChild(makeEl('span')); el.children[0].className = 'katex' },
+  }
+  const R2 = loadReader({ katex: fake })
+  assert.deepEqual([...R2.t.trRenderBody('A $x$ B')], [])
+  // 每个公式现在是三步：① resolveMathMode 的探测（renderToString + throwOnError:true）
+  //                      ② renderMathSegment 的探测（同上）③ 真渲染（render + throwOnError:false）
+  assert.equal(calls.filter((c) => c.fn === 'renderToString').length, 2, `探测应恰有两次：${calls.map((c) => c.fn)}`)
+  assert.equal(calls.filter((c) => c.fn === 'render').length, 1, '真渲染应恰有一次')
+  const probes = calls.filter((c) => c.fn === 'renderToString')
+  const render = calls.find((c) => c.fn === 'render')
+  for (const c of calls) {
+    assert.equal(c.opts.trust, false, '必须 trust:false（不产原始 HTML）')
+    assert.equal(c.opts.strict, 'ignore', "必须 strict:'ignore'")
+  }
+  for (const p of probes) assert.equal(p.opts.throwOnError, true, '探测必须 throwOnError:true，失败才能被抓住并降级')
+  assert.equal(render.opts.throwOnError, false, '真渲染必须 throwOnError:false（契约参数）')
+  assert.equal(render.tex, 'x')
+  assert.equal(render.el._classes.has('tr-math'), true)
+  assert.equal(render.opts.displayMode, false, '普通行内公式仍按行内渲染（模式解析零误伤）')
+})
+
+test('K5 气泡既有契约不变：零 button、#tr-note 纯文本、#tr-status 仍走 textContent', () => {
+  const R = loadReader()
+  assert.deepEqual([...R.t.trRenderBody('译文 $x_t$ 与文字')], [])
+  R.t.showTrPop('', '译文 $x_t$ 与文字', '')
+  const body = R.els.get('tr-body')
+  const note = R.els.get('tr-note')
+  assert.equal(body.children.filter((e) => /BUTTON/i.test(e.tagName)).length, 0, '气泡正文零 button')
+  assert.equal(note.children.length, 0, '#tr-note 必须是纯文本（不建子元素）')
+  assert.equal(typeof note.textContent, 'string')
+  // 失败时提示也只进 #tr-note，且 #tr-body 里没有警示符号（提示不混进正文）
+  R.t.showTrPop('', '译文 $\\frac{1}{$', '')
+  assert.ok(!String(R.els.get('tr-body').textContent).includes('⚠'), '#tr-body 里不得混入提示文案')
+  assert.match(R.els.get('tr-note').textContent, /未能渲染/)
+  assert.equal(R.els.get('tr-body').children.filter((e) => /BUTTON/i.test(e.tagName)).length, 0)
+})
+
+test('K6 vendored KaTeX 是离线资源：无 CDN、带版本/许可证、CSS 与字体齐备', () => {
+  const html = readFileSync(join(REPO, 'reader', 'index.html'), 'utf8')
+  assert.match(html, /<link rel="stylesheet" href="\/paper-reader\/vendor\/katex\.min\.css">/, '必须以本地扁平路径引 CSS')
+  assert.match(html, /<script src="\/paper-reader\/vendor\/katex\.min\.js"><\/script>/, '必须以本地扁平路径引 JS')
+  for (const tag of html.match(/<(?:link|script)[^>]*(?:katex)[^>]*>/g) ?? []) {
+    assert.ok(!/https?:\/\//.test(tag), `KaTeX 资源不得引 CDN：${tag}`)
+  }
+  const js = readFileSync(KATEX_JS, 'utf8')
+  const css = readFileSync(KATEX_CSS, 'utf8')
+  assert.match(js, /version:"0\.16\.22"/, 'vendored JS 必须能读出 0.16.22')
+  assert.ok(css.includes('url(KaTeX_'), 'CSS 必须引用同目录的 KaTeX_*.woff2（拉平后不带 fonts/ 前缀）')
+  const noticeKind = readFileSync(join(REPO, 'reader', 'vendor', 'katex.NOTICE.md'), 'utf8')
+  assert.match(noticeKind, /0\.16\.22/)
+  assert.match(readFileSync(join(REPO, 'reader', 'vendor', 'katex.LICENSE'), 'utf8'), /MIT License/)
+  for (const f of ['KaTeX_Main-Regular.woff2', 'KaTeX_Math-Italic.woff2', 'KaTeX_Size1-Regular.woff2']) {
+    assert.ok(readFileSync(join(REPO, 'reader', 'vendor', f)).length > 0, `缺字体 ${f}`)
+  }
+})
+
+test('K7 反例：金额 / 落单 $ / 代码里的 $ / 中文标点里的 $ 一律不得当数学（过度识别更糟）', () => {
+  const R = loadReader()
+  const sp = (x) => JSON.parse(JSON.stringify(R.t.splitTranslatedMath(x)))
+  // 全部必须是「一段文本」，不得出现 kind==='math'（否则正文会被 KaTeX 吃掉）
+  for (const [label, input] of [
+    ['金额（两个 $ 之间是散文）', '价格 $5 到 $10 不等，共 $30。'],
+    ['金额（同一句里配对）', 'That costs $5 and that $10.'],
+    ['落单 $', '一个孤零零的 $ 符号'],
+    ['代码里的 $（环境变量/路径）', 'export PATH=$HOME/bin:$PATH 然后重开终端'],
+    ['代码里的 $（shell 变量）', '把 $FLAG 设为 1，再读 $OUT'],
+    ['中文标点里的 $', '「单价 $5，优惠 $3」—— 这是正文里的美元号'],
+    ['只有空白', '$   $'],
+    ['未闭合', '开头 $x^2 没有闭合'],
+  ]) {
+    const segs = sp(input)
+    assert.deepEqual(segs, [{ kind: 'text', text: input }], `${label} 必须整段当文本：${JSON.stringify(segs)}`)
+  }
+  // 但真的公式仍要认（正对照，避免「一律不认」也能骗过上面的用例）
+  assert.equal(sp('切线 $x^2$ 与 $\\frac{a}{b}$ 都算').filter((x) => x.kind === 'math').length, 2)
+  // 渲染这些反例：正文不许被吃掉，也不该出现降级提示
+  assert.deepEqual([...R.t.trRenderBody('价格 $5 到 $10 不等，共 $30。')], [])
+  assert.equal(R.els.get('tr-body').textContent, '价格 $5 到 $10 不等，共 $30。')
+  const note = R.doc.getElementById('tr-note')   // 惰性创建：先取一次再断言
+  assert.ok(!/未能渲染/.test(note.textContent), `反例不该出现降级提示：${note.textContent}`)
+})
+
+test('K8 真实论文的展示公式（服务端包成行内 $…$ + 自带 \\tag）必须被判成展示模式并渲染成功', () => {
+  const R = loadReader()
+  // 与线上一致的形态：assembleSource 把 equation 的 LaTeX 压成单行、再包一层**行内** $…$
+  const inline = DONG_EQUATIONS.map((raw) => {
+    let tex = raw.trim()
+    if (tex.startsWith('$$') && tex.endsWith('$$')) tex = tex.slice(2, -2)
+    tex = tex.replace(/\s*\n\s*/g, ' ')   // 服务端的 compactLatex 口径：折行压平（保留单空格）
+    return { tex, src: `$${tex}$` }
+  })
+  assert.equal(inline.length, 18, '夹具必须是 Dong 那篇的全部 18 个 equation')
+  const withTag = inline.filter((x) => x.tex.includes('\\tag'))
+  assert.ok(withTag.length >= 14, `这批公式大多带 \\tag（实测 ${withTag.length}/18）——正是 P1 的触发条件`)
+
+  inline.forEach(({ tex, src }, i) => {
+    const failed = [...R.t.trRenderBody(src)]
+    assert.deepEqual(failed, [], `第 ${i + 1} 个 equation（行内形态，含 \\tag：${tex.includes('\\tag')}）必须渲染成功，不得降级`)
+    const segs = R.els.get('tr-body').children
+    assert.equal(segs.length, 1, `第 ${i + 1} 个 equation 应恰好一段数学`)
+    assert.ok(segs[0]._classes.has('tr-math'), `第 ${i + 1} 个 equation 必须是数学段`)
+    assert.ok(!segs[0]._classes.has('tr-math-fallback'), `第 ${i + 1} 个 equation 不得走降级`)
+    assert.ok(segs[0].children.length > 0, `第 ${i + 1} 个 equation 不得留白`)
+    if (tex.includes('\\tag')) {
+      // \tag 只允许展示模式 ⇒ 必须被 resolveMathMode 升级成块级（而源定界符只是行内 $）
+      assert.ok(segs[0]._classes.has('tr-math-block'), `带 \\tag 的第 ${i + 1} 个 equation 必须升级为展示模式`)
+    }
+  })
+})
+
+test('K9 模式解析零误伤：普通行内公式仍按行内渲染（不会因为「会失败就升级」而全变块级）', () => {
+  const R = loadReader()
+  assert.deepEqual([...R.t.trRenderBody('设 $x_t$ 为状态，$QK^T$ 是注意力得分')], [])
+  const segs = R.els.get('tr-body').children.filter((e) => e._classes.has('tr-math'))
+  assert.equal(segs.length, 2)
+  for (const e of segs) {
+    assert.ok(!e._classes.has('tr-math-block'), '能按行内渲染的公式不得被升级成块级（否则排版被拆散）')
+    assert.equal(e.tagName, 'SPAN')
+  }
+  // 反向：只有行内确实失败时才升级（\\tag 是 KaTeX 的硬规则）
+  assert.deepEqual([...R.t.trRenderBody('$E=mc^2 \\tag{1}$')], [])
+  const tagged = R.els.get('tr-body').children.find((e) => e._classes.has('tr-math'))
+  assert.ok(tagged._classes.has('tr-math-block'), '\\tag 行内渲染不了 ⇒ 必须升级成展示模式')
+})
diff --git a/test/library-clear-and-busy.test.mjs b/test/library-clear-and-busy.test.mjs
index 4a62025..267ac3f 100644
--- a/test/library-clear-and-busy.test.mjs
+++ b/test/library-clear-and-busy.test.mjs
@@ -791,13 +791,15 @@ test('C4 【F-J】content_list 形态按通道区分：本地 legacy = JSON 字
   assert.match(m, /vlm[^\n]*未(实测|验证)|未(实测|验证)[^\n]*vlm/, 'src 注释也要列出未验证项')
 })
 
-test('C3 README 版本标签与 package.json 同步（不再残留 1.5.0/1.6.0）', () => {
-  // 期望值跟着 package.json 走：发版只改三处（package.json + 两个 README），本测试不再逐版手写
+test('C3 README 版本标签与 package.json 同步（不残留其它 1.x.0 版本号）', () => {
+  // 以 package.json 为**单一事实源**，不再把版本号硬编码进测试（每 bump 一次就要改测试 = 假守卫；
+  // 本功能的 1.6.0 → 1.5.0 重排就是被这条抓到的）。仍然拦「README 落后于包版本」这种真实漂移。
   const v = JSON.parse(readFileSync(join(REPO, 'package.json'), 'utf8')).version
-  const vEsc = v.replaceAll('.', '\\.')
+  assert.match(v, /^\d+\.\d+\.\d+$/, `package.json 版本格式异常：${v}`)
   for (const f of ['README.md', 'README_EN.md']) {
     const t = readFileSync(join(REPO, f), 'utf8')
-    assert.ok(!/1\.5\.0|1\.6\.0/.test(t), `${f} 残留旧版本号：${(t.match(/1\.[56]\.0/g) || []).join(', ')}`)
-    assert.match(t, new RegExp(`v${vEsc}|@${vEsc}`), `${f} 必须出现 v${v} / @${v}`)
+    assert.ok(t.includes(`v${v}`) || t.includes(`@${v}`), `${f} 必须出现当前版本 v${v} / @${v}`)
+    const others = [...new Set([...t.matchAll(/[v@](\d+\.\d+\.\d+)/g)].map((m) => m[1]).filter((x) => x !== v))]
+    assert.deepEqual(others, [], `${f} 残留其它版本号：${others.join(', ')}`)
   }
 })
diff --git a/test/merge-verify-t3-library.test.mjs b/test/merge-verify-t3-library.test.mjs
new file mode 100644
index 0000000..c55ca30
--- /dev/null
+++ b/test/merge-verify-t3-library.test.mjs
@@ -0,0 +1,513 @@
+// test/merge-verify-t3-library.test.mjs — t3 独立验证：整合后**五条**文献管理入口的穿越防护与语义
+//
+// 与实现方 t2 用例的差别（方法独立性）：
+//   · 快照是**逐文件 sha256 内容级**（不是 size+mtime）：库外哨兵与文献库本身都要字节级零变化；
+//   · **规范化路由名**（/api/library/{delete,rename}-{topic,paper}，上游 UI 走的那套）与我们的别名
+//     两侧都打同一套矩阵，且 409/503 语义在**规范化名**上单独验证（既有用例只覆盖别名）；
+//   · 删除后**真的把回收站里的文件搬回去**，与删除前的 sha256 逐字节比对（可恢复性不靠"文件还在"）；
+//   · 创建/删除对称性用「一批能创建的名字」闭环验证。
+//
+// 只 import dist/*.js；破坏性操作一律在 /tmp 临时库，绝不碰真实文献库。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import { spawnSync } from 'node:child_process'
+import { createHash } from 'node:crypto'
+import {
+  chmodSync, existsSync, lstatSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, renameSync, rmSync, symlinkSync, writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { canStoreControlName, chmodBlocksRename } from './fs-probe.mjs'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const dist = (m) => join(ROOT, '..', 'dist', m)
+const HOME = mkdtempSync(join(tmpdir(), 'dpr-mv3-home-'))
+process.env.DSH_HOME = HOME
+
+const { registerRoutes } = await import(pathToFileURL(dist('host.js')).href)
+
+/* ── 夹具 ─────────────────────────────────────────────────────────────────── */
+const PDF = Buffer.from('%PDF-1.4\n1 0 obj\n<< /Type /Catalog >>\nendobj\ntrailer\n<< /Size 1 /Root 1 0 R >>\n%%EOF\n', 'latin1')
+const CANON = {
+  deletePaper: '/api/library/delete-paper',
+  renamePaper: '/api/library/rename-paper',
+  deleteTopic: '/api/library/delete-topic',
+  renameTopic: '/api/library/rename-topic',
+  upload: '/api/library/upload',
+}
+const ALIAS = {
+  deletePaper: '/api/library/paper/delete',
+  renamePaper: '/api/library/paper/rename',
+  deleteTopic: '/api/library/topic/delete',
+  renameTopic: '/api/library/topic/rename',
+}
+
+let spec = null
+const makeCtx = (over = {}) => ({
+  webServer: { register: (s) => { spec = s; return () => {} } },
+  connection: { requestRejection: () => undefined },
+  sessionController: { list: async () => ({ items: [] }) },
+  workspaceController: {}, workspaceRegistry: {},
+  effect: (fn) => fn(),
+  ...over,
+})
+const servers = []
+async function boot(dataDir, over = {}) {
+  registerRoutes(makeCtx(over), { dataDir })
+  const srv = createServer((req, res) => spec.handler(req, res))
+  await new Promise((r) => srv.listen(0, '127.0.0.1', r))
+  srv.unref?.()
+  servers.push(srv)
+  return `http://127.0.0.1:${srv.address().port}/paper-reader`
+}
+
+/** 逐文件 sha256 快照（内容级；符号链接记 'L'）。 */
+function snap(dir) {
+  const out = {}
+  const walk = (d) => {
+    let entries = []
+    try { entries = readdirSync(d, { withFileTypes: true }) } catch { return }
+    for (const e of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const p = join(d, e.name)
+      let st
+      try { st = lstatSync(p) } catch { continue }
+      if (st.isSymbolicLink()) { out[p] = 'L'; continue }
+      if (st.isDirectory()) { out[p] = 'D'; walk(p); continue }
+      out[p] = 'F:' + createHash('sha256').update(readFileSync(p)).digest('hex')
+    }
+  }
+  walk(dir)
+  return out
+}
+const diffSnap = (a, b) => [...new Set([...Object.keys(a), ...Object.keys(b)])].filter((k) => a[k] !== b[k])
+
+/** 造一篇带全部派生产物的文献。 */
+function scaffold(dataDir, topic, name) {
+  const dir = join(dataDir, topic)
+  mkdirSync(dir, { recursive: true })
+  writeFileSync(join(dir, `${name}.pdf`), PDF)
+  for (const s of ['.txt', '.pages.json', '.transcript.json', '.mineru.md', '.mineru.json', '.embeddings.json']) writeFileSync(join(dir, name + s), `${name}${s} payload`)
+  for (const v of ['-en', '-zh', '-dual']) writeFileSync(join(dir, `${name}${v}.pdf`), `${name}${v}`)
+  writeFileSync(join(dir, `${name}.pdf.tmp-9988-aabbccdd`), 'tmp')
+  return dir
+}
+
+/* ── 入口 1：越界矩阵（五入口 × 规范化名/别名），库外零变化 ─────────────────── */
+test('V1 五入口 × 越界矩阵：规范化路由名与别名两侧全部 4xx，且库内容/库外哨兵字节级零变化', async () => {
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data-'))
+  const OUTSIDE = mkdtempSync(join(tmpdir(), 'dpr-mv3-out-'))
+  mkdirSync(join(OUTSIDE, 'sentinel-dir'), { recursive: true })
+  writeFileSync(join(OUTSIDE, 'sentinel.txt'), 'must stay byte-identical')
+  writeFileSync(join(OUTSIDE, 'sentinel-dir', 'inner.txt'), 'must stay')
+  scaffold(DATA, 'victim', 'Paper')
+  scaffold(DATA, 'victim', 'Paper Long')
+  const base = await boot(DATA)
+
+  const post = async (p, obj) => {
+    const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(obj) })
+    const text = await r.text()
+    let body = null
+    try { body = JSON.parse(text) } catch { /* 非 JSON */ }
+    return { status: r.status, body, text }
+  }
+  const upload = async (topic, name) => {
+    const r = await fetch(base + CANON.upload, {
+      method: 'POST',
+      headers: { 'x-dpr-topic': encodeURIComponent(topic), 'x-dpr-name': encodeURIComponent(name), 'content-type': 'application/pdf' },
+      body: PDF,
+    })
+    const text = await r.text()
+    let body = null
+    try { body = JSON.parse(text) } catch { /* 非 JSON */ }
+    return { status: r.status, body, text }
+  }
+
+  // 越界输入（我自造的一套）：**路径形状**的才进严格矩阵（含分隔符 / 就是 . 或 .. / 绝对路径 / NUL /
+  // 空白 / 保留名 .trash）。URL 编码残留与裸控制字符不含分隔符，属"命名卫生"而非越界，
+  // 放在 TOLERATED 里验证"要么被拒、要么可被同名删除（不留孤儿）"，见下。
+  const EVIL = [
+    '..', '../', '../../..', 'a/../../b', '....//....//etc', '/etc/passwd',
+    join(OUTSIDE, 'sentinel.txt'), join(OUTSIDE, 'sentinel-dir'), OUTSIDE,
+    'x\u0000y', 'a\\..\\..\\b', 'C:\\Windows', 'a/b', '.', '', '   ', '.trash', '.. ',
+  ]
+  const beforeOut = snap(OUTSIDE)
+  const beforeData = snap(DATA)
+  const rejected = []
+  const assert4xx = (r, why) => {
+    assert.ok(r.status >= 400 && r.status < 500, `${why} 必须 4xx，实得 ${r.status} ${r.text.slice(0, 200)}`)
+    assert.ok(typeof r.body?.code === 'string' && r.body.code.length > 0, `${why} 必须带机器可读 code：${r.text.slice(0, 200)}`)
+    assert.ok(!r.text.includes(OUTSIDE), `${why} 响应不得回显库外绝对路径`)
+    rejected.push(why)
+  }
+
+  for (const x of EVIL) {
+    for (const p of [CANON.deleteTopic, ALIAS.deleteTopic]) {
+      assert4xx(await post(p, { topic: x, name: x, confirmName: x }), `${p} topic=${JSON.stringify(x)}`)
+    }
+    for (const p of [CANON.renameTopic, ALIAS.renameTopic]) {
+      assert4xx(await post(p, { topic: x, name: x, to: 'zz', newName: 'zz' }), `${p} from=${JSON.stringify(x)}`)
+    }
+    for (const p of [CANON.deletePaper, ALIAS.deletePaper]) {
+      assert4xx(await post(p, { topic: 'victim', name: x }), `${p} name=${JSON.stringify(x)}`)
+      assert4xx(await post(p, { topic: x, name: 'Paper' }), `${p} topic=${JSON.stringify(x)}`)
+    }
+    for (const p of [CANON.renamePaper, ALIAS.renamePaper]) {
+      assert4xx(await post(p, { topic: 'victim', name: 'Paper', to: x }), `${p} to=${JSON.stringify(x)}`)
+      assert4xx(await post(p, { topic: x, name: 'Paper', to: 'ok' }), `${p} topic=${JSON.stringify(x)}`)
+    }
+    assert4xx(await upload(x, 'u.pdf'), `upload topic=${JSON.stringify(x)}`)
+    assert4xx(await upload('victim', `${x}.pdf`), `upload name=${JSON.stringify(x)}`)
+  }
+  assert.ok(rejected.length >= 150, `越界矩阵规模（实测 ${rejected.length} 次拒绝）`)
+  console.log(`  越界矩阵：${rejected.length} 次拒绝（每条 4xx + code），库/库外 sha256 零变化`)
+  assert.deepEqual(diffSnap(beforeOut, snap(OUTSIDE)), [], '库外哨兵目录必须逐字节零变化')
+  assert.deepEqual(diffSnap(beforeData, snap(DATA)), [], '被拒请求不得改动文献库')
+  // 反证：正常请求仍能成功（矩阵不是"凡请求都拒"）
+  const okDel = await post(CANON.deletePaper, { topic: 'victim', name: 'Paper' })
+  assert.equal(okDel.status, 200, okDel.text)
+})
+
+/* ── 入口 1b：不含分隔符的"可疑字面名"——要么被拒，要么可被同名删除（不留孤儿） ── */
+test('V1b 可疑字面名（URL 编码残留 / 裸控制字符）：不产生孤儿、库外仍零变化', async () => {
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data1b-'))
+  const OUTSIDE = mkdtempSync(join(tmpdir(), 'dpr-mv3-out1b-'))
+  writeFileSync(join(OUTSIDE, 'sentinel.txt'), 'must stay')
+  scaffold(DATA, 't', 'Paper')
+  scaffold(DATA, 't', 'Bystander')
+  const base = await boot(DATA)
+  const post = async (p, obj) => {
+    const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(obj) })
+    const text = await r.text(); let body = null
+    try { body = JSON.parse(text) } catch { /* */ }
+    return { status: r.status, body, text }
+  }
+  const beforeOut = snap(OUTSIDE)
+  const report = []
+  let i = 0
+  for (const x of ['%2e%2e%2f', '..%2f..', 'x\u0001y', 'CON', 'a b']) {
+    const from = `P${++i}`
+    scaffold(DATA, 't', from)
+    // 文献名侧：改名到一个字面名，若成功则必须能用同名删掉（创建/删除对称 → 不留孤儿）
+    const r = await post(CANON.renamePaper, { topic: 't', name: from, to: x })
+    report.push(`rename-paper ${from} → ${JSON.stringify(x)} : ${r.status}`)
+    if (r.status === 200) {
+      const d = await post(CANON.deletePaper, { topic: 't', name: x })
+      report.push(`  delete-paper name=${JSON.stringify(x)} : ${d.status}`)
+      assert.equal(d.status, 200, `改名成的字面名必须能删掉（否则是孤儿）：${d.text}`)
+      assert.ok(!existsSync(join(DATA, 't', `${x}.pdf`)), '删掉后不得残留 .pdf')
+    } else {
+      assert.ok(r.status >= 400 && r.status < 500, `被拒必须是 4xx：${r.status}`)
+      assert.ok(existsSync(join(DATA, 't', `${from}.pdf`)), '被拒时不得改动原文献')
+    }
+    // 专题侧：同一字面名要么被拒，要么用完能删（此处只记录，不作为判据）
+    const t = await post(CANON.deleteTopic, { topic: x, confirmName: x })
+    report.push(`  delete-topic topic=${JSON.stringify(x)} : ${t.status}`)
+  }
+  assert.deepEqual(diffSnap(beforeOut, snap(OUTSIDE)), [], '库外哨兵目录必须逐字节零变化')
+  console.log('  可疑字面名观测：\n    ' + report.join('\n    '))
+})
+
+/* ── 入口 2：符号链接逃逸 ─────────────────────────────────────────────────── */
+test('V2 符号链接：专题→库外目录、文献 .pdf→库外文件，五入口一律 4xx 且链接目标无损', async () => {
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data2-'))
+  const OUTSIDE = mkdtempSync(join(tmpdir(), 'dpr-mv3-out2-'))
+  writeFileSync(join(OUTSIDE, 'sentinel.txt'), 'must stay')
+  scaffold(DATA, 'vic', 'P')
+  symlinkSync(OUTSIDE, join(DATA, 'evil'), 'dir')
+  symlinkSync(join(OUTSIDE, 'sentinel.txt'), join(DATA, 'vic', 'link.pdf'), 'file')
+  const base = await boot(DATA)
+  const post = async (p, obj) => {
+    const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(obj) })
+    const text = await r.text(); let body = null
+    try { body = JSON.parse(text) } catch { /* */ }
+    return { status: r.status, body, text }
+  }
+  const before = snap(OUTSIDE)
+  const cases = [
+    [CANON.deleteTopic, { topic: 'evil', confirmName: 'evil' }], [ALIAS.deleteTopic, { name: 'evil', confirmName: 'evil' }],
+    [CANON.renameTopic, { topic: 'evil', to: 'x' }], [ALIAS.renameTopic, { name: 'evil', newName: 'x' }],
+    [CANON.deletePaper, { topic: 'evil', name: 'sentinel' }], [CANON.deletePaper, { topic: 'vic', name: 'link' }],
+    [CANON.renamePaper, { topic: 'vic', name: 'link', to: 'z' }],
+  ]
+  for (const [p, body] of cases) assert.ok((await post(p, body)).status >= 400, `${p} ${JSON.stringify(body)} 必须被拒`)
+  const up = await fetch(base + CANON.upload, {
+    method: 'POST',
+    headers: { 'x-dpr-topic': encodeURIComponent('evil'), 'x-dpr-name': encodeURIComponent('u.pdf'), 'content-type': 'application/pdf' },
+    body: PDF,
+  })
+  assert.ok(up.status >= 400, 'upload 到符号链接专题必须被拒')
+  assert.deepEqual(diffSnap(before, snap(OUTSIDE)), [], '符号链接目标（库外）必须零变化')
+  assert.ok(lstatSync(join(DATA, 'evil')).isSymbolicLink(), '链接本身必须还在（只拒绝、不销毁）')
+})
+
+/* ── 入口 3：回收站可恢复 + .pdf 最后移 + 精确 stem + manifest ─────────────── */
+test('V3 删除语义：整批产物进 .trash、.pdf 最后移、manifest 可读、**搬回来逐字节等于删除前**', async () => {
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data3-'))
+  scaffold(DATA, 't', 'Attention')
+  scaffold(DATA, 't', 'Attention Is All You Need')
+  scaffold(DATA, 't', 'Attention2')
+  const base = await boot(DATA)
+  const before = snap(join(DATA, 't'))
+  const r = await fetch(base + CANON.deletePaper, {
+    method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ topic: 't', name: 'Attention' }),
+  })
+  const body = await r.json()
+  assert.equal(r.status, 200, JSON.stringify(body))
+  assert.equal(body.moved[body.moved.length - 1], 'Attention.pdf', '`.pdf` 必须最后移（失败时文献仍在库里可见）')
+  assert.ok(body.moved.includes('Attention-dual.pdf') && body.moved.includes('Attention.mineru.json'), '派生产物整批移走')
+  assert.ok(body.moved.some((f) => f.includes('.tmp-')), '在途临时文件也要移走')
+  // 精确 stem：同前缀的其他文献一个字节都不许变
+  // 快照 key 是**绝对路径**：win32 上是反斜杠，原先写死 '/' 的正则在 Windows 上永不命中 ⇒ 过滤不掉
+  // 本文件的产物、断言必红（CI run 38193897047 的 V3）。改用 basename（跨平台且更严格）。
+  const isAttention = (p) => /^Attention([.-]|$)/.test(String(p).split(/[\\/]/).pop())
+  // 回归护栏：过滤器不得依赖路径分隔符（快照 key 在 win32 上是反斜杠。CI run 38193897047 的 V3 就是
+  // 写死 '/' 的版本在 Windows 上永不命中）。这两行在任何平台都能把「改回写死 '/'」的变异判红。
+  assert.ok(isAttention('C:\\data\\t\\Attention-dual.pdf'), 'isAttention 必须认 win32 反斜杠绝对路径')
+  assert.ok(!isAttention('C:\\data\\t\\Attention Is All You Need.pdf'), '同前缀的其它文献不得被误过滤')
+  assert.ok(!isAttention('/data/t/Attention2.mineru.json'), 'Attention2 不得被误过滤')
+  const afterRest = Object.fromEntries(Object.entries(snap(join(DATA, 't'))).filter(([k]) => !isAttention(k)))
+  const beforeRest = Object.fromEntries(Object.entries(before).filter(([k]) => !isAttention(k)))
+  assert.deepEqual(afterRest, beforeRest, '精确 stem：不得连带 Attention Is All You Need / Attention2')
+  // 回收站 + manifest
+  const trash = join(DATA, body.trashRel)
+  assert.ok(existsSync(join(trash, 'manifest.json')), '回收站必须有 manifest.json')
+  const manifest = JSON.parse(readFileSync(join(trash, 'manifest.json'), 'utf8'))
+  assert.ok(Array.isArray(manifest.files ?? manifest.moved ?? Object.values(manifest)) || typeof manifest === 'object', 'manifest 必须可读')
+  for (const f of body.moved) assert.ok(existsSync(join(trash, f)), `${f} 必须真的在回收站里`)
+  // **搬回来**（恢复）后必须与删除前逐字节一致
+  const restored = {}
+  for (const f of body.moved) {
+    const src = join(trash, f)
+    const dst = join(DATA, 't', f)
+    renameSync(src, dst)
+    restored[join(DATA, 't', f)] = 'F:' + createHash('sha256').update(readFileSync(dst)).digest('hex')
+  }
+  for (const [p, h] of Object.entries(restored)) assert.ok(before[p] === h || before[p + '.pdf'] === h, `恢复后的 ${p} 必须与删除前逐字节一致`)
+  assert.equal(Object.keys(before).length, Object.keys(snap(join(DATA, 't'))).length, '恢复后文件集合与删除前一致')
+})
+
+/* ── 入口 4：409/503 在**规范化路由名**上也成立 ────────────────────────────── */
+test('V4 规范化路由名上的 409/503：运行中会话、无法确认的会话状态、翻译中', async (t) => {
+  if (process.getuid && process.getuid() === 0) return t.skip('root 环境下不可写目录用例不适用')
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data4-'))
+  scaffold(DATA, 'sess', 'S')
+  scaffold(DATA, 'sess2', 'S2')
+  const running = [{ id: 'x1', topic: 'sess', name: 'S', status: 'running' }]
+  void running
+  // 与该文献 id 前缀匹配的会话（前缀算法与 host 一致；见 sessionPrefixFor）
+  const fakeSession = (topic, name, n = 1, isRunning = true) => ({
+    sessionId: `dpr-${Buffer.from(`${topic}/${name}`).toString('base64url')}-${n}`,
+    updatedAt: Date.now(), running: isRunning, blank: false,
+  })
+  let sessions = [fakeSession('sess', 'S', 1, true), fakeSession('sess', 'S', 2, false)]
+  let mode = 'running'
+  const base = await boot(DATA, {
+    sessionController: {
+      list: async () => {
+        if (mode === 'throw') throw new Error('controller down')
+        return { items: mode === 'running' ? sessions : [] }
+      },
+    },
+  })
+  const post = async (p, obj) => {
+    const r = await fetch(base + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(obj) })
+    const text = await r.text(); let body = null
+    try { body = JSON.parse(text) } catch { /* */ }
+    return { status: r.status, body, text }
+  }
+  const before = snap(DATA)
+  const del = await post(CANON.deletePaper, { topic: 'sess', name: 'S' })
+  assert.equal(del.status, 409); assert.equal(del.body.code, 'session-running')
+  assert.equal(del.body.sessions.running, 1, '响应要如实回报 running 数')
+  const ren = await post(CANON.renamePaper, { topic: 'sess', name: 'S', to: 'X' })
+  assert.equal(ren.status, 409); assert.equal(ren.body.code, 'session-running')
+  const tdel = await post(CANON.deleteTopic, { topic: 'sess', confirmName: 'sess' })
+  assert.equal(tdel.status, 409)
+  assert.ok(['topic-not-empty', 'session-running'].includes(tdel.body.code), `专题删除被拒：${tdel.text}`)
+  const tren = await post(CANON.renameTopic, { topic: 'sess', to: 'sess-x' })
+  assert.equal(tren.status, 409); assert.equal(tren.body.code, 'session-running')
+  assert.deepEqual(diffSnap(before, snap(DATA)), [], '被 409 拒绝时盘上必须零变化')
+
+  // 会话状态无法确认 → 503 session-unknown（宁可拒绝也不误删）
+  mode = 'throw'
+  const unknown = await post(CANON.deletePaper, { topic: 'sess2', name: 'S2' })
+  assert.equal(unknown.status, 503, unknown.text)
+  assert.equal(unknown.body.code, 'session-unknown')
+
+  // 翻译进行中 → 409 translation-busy（假 babeldoc 造真 busy，不做任何真实翻译）
+  mode = 'none'
+  const TX = mkdtempSync(join(tmpdir(), 'dpr-mv3-tx-'))
+  const txData = join(TX, 'data')
+  const pidFile = join(TX, 'pid')
+  process.env.MV3_TX_PIDFILE = pidFile
+  mkdirSync(join(txData, 'tx'), { recursive: true })
+  writeFileSync(join(txData, 'tx', 'paper.pdf'), PDF)
+  writeFileSync(join(txData, 'tx', 'paper.txt'), 'cache')
+  const binPath = join(TX, '.venv-pdf2zh', 'bin', 'babeldoc')
+  mkdirSync(join(TX, '.venv-pdf2zh', 'bin'), { recursive: true })
+  // 假 babeldoc：`sleep 30`（不是 120）是**兜底**——pidfile 竞态导致 kill 打空时，文件也能在 30s 内
+  // 自行退出（< 60s 的 --test-timeout），不会像 CI run 38193897047 的 macOS 那样整文件超时。
+  writeFileSync(binPath, '#!/bin/sh\ncase "$1" in\n  --version) echo "babeldoc fake 1.0"; exit 0 ;;\n  --help) echo "--no-watermark --skip-figure-text"; exit 0 ;;\n  *) echo $$ > "$MV3_TX_PIDFILE"; exec sleep 30 ;;\nesac\n')
+  chmodSync(binPath, 0o755)
+  const txBase = await boot(txData)
+  const { startTranslation, zhStatus } = await import(pathToFileURL(dist('translate.js')).href)
+  const { resolvePaper } = await import(pathToFileURL(dist('library.js')).href)
+  const ref = resolvePaper(txData, { topic: 'tx', name: 'paper' })
+  const started = await startTranslation(ref, txData, { baseUrl: 'http://127.0.0.1:9/v1', apiKey: 'k', model: 'm' })
+  assert.equal(started.started, true, JSON.stringify(started))
+  assert.equal(zhStatus(ref).busy, true)
+  const txPost = async (p, obj) => {
+    const r = await fetch(txBase + p, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(obj) })
+    const text = await r.text(); let body = null
+    try { body = JSON.parse(text) } catch { /* */ }
+    return { status: r.status, body, text }
+  }
+  const tdel2 = await txPost(CANON.deletePaper, { topic: 'tx', name: 'paper' })
+  assert.equal(tdel2.status, 409, tdel2.text); assert.equal(tdel2.body.code, 'translation-busy')
+  const tren2 = await txPost(CANON.renamePaper, { topic: 'tx', name: 'paper', to: 'paper2' })
+  assert.equal(tren2.status, 409, tren2.text); assert.equal(tren2.body.code, 'translation-busy')
+  assert.ok(existsSync(join(txData, 'tx', 'paper.pdf')), '被拒后文献仍在')
+  assert.ok(!existsSync(join(txData, 'tx', 'paper-zh.pdf')), '不得产出译文')
+  // 「制造翻译中」这条路在**本平台能否真的跑起来**是平台能力，实测决定（不硬编码平台）：
+  //   · POSIX：产品按 <dataDir>/../.venv-pdf2zh/bin/babeldoc 找到我们造的 sh 假引擎并执行 → 会留下
+  //     `sleep` 子进程（macOS 上那个 pidfile 竞态就是它撑住 event loop）；
+  //   · Win32：产品按 venv 约定只找 `Scripts/babeldoc.exe`（真实 PE），我们的 sh 脚本**既不在它的搜索位、
+  //     也无法执行** ⇒ 根本没有子进程要清，产品停在引擎解析/自动安装阶段（`busy` 仍为真 —— CI run
+  //     38195117216 的 windows 实测就是这个状态；t17 加的「必须留下 pidfile」断言在那里恒假，本次修）。
+  //     注意：`src/translate.ts` 里 `findBabeldoc` 的引擎路径是**产品约定**，且该文件携带用户未提交的
+  //     NO_PROXY 修复（本任务 Out-of-scope），所以不去给产品加注入 seam，改用实测能力 + 等价断言。
+  const canRunFakeEngine = spawnSync(binPath, ['--version'], { encoding: 'utf8' }).status === 0
+  if (canRunFakeEngine) {
+    // 等 pidfile 出现再 kill：脚本「先写 pid 再 exec sleep」，但 spawn→shell→落盘要几毫秒；macOS 上这个
+    // 竞态会让 kill 打空 → sleep 子进程留下来把整个文件的 event loop 撑到 60s 超时（CI run 38193897047
+    // 的 macOS「所有子用例 ok 但文件 timeout」正是它）。这里轮询最多 5s。
+    const killTxChild = () => {
+      if (!existsSync(pidFile)) return false
+      const pid = readFileSync(pidFile, 'utf8').trim()
+      if (!/^\d+$/.test(pid)) return false
+      try { process.kill(+pid, 'SIGKILL') } catch { /* 已退出 */ }
+      return true
+    }
+    const deadline = Date.now() + 5000
+    while (!killTxChild() && Date.now() < deadline) await new Promise((r) => setTimeout(r, 25))
+    assert.ok(existsSync(pidFile), '假 babeldoc 必须已启动并写下 pid（否则上面的 busy 断言无从谈起）')
+  } else {
+    t.diagnostic('本平台执行不了假引擎（Win32 按 Scripts/babeldoc.exe 找真实可执行文件）⇒ 无 sleep 子进程可清；'
+      + '改为验同一条「翻译中」语义：busy 一直为真、再次删除仍 409 translation-busy、文件零改动')
+    assert.equal(zhStatus(ref).busy, true, '等价断言：此刻必须仍是「翻译中」')
+    const again = await txPost(CANON.deletePaper, { topic: 'tx', name: 'paper' })
+    assert.equal(again.status, 409, again.text)
+    assert.equal(again.body.code, 'translation-busy')
+    assert.equal(zhStatus(ref).busy, true, '等价断言：被拒之后仍是「翻译中」（没被误清）')
+    assert.ok(existsSync(join(txData, 'tx', 'paper.pdf')), '等价断言：被拒之后文献本体仍在、零改动')
+  }
+})
+
+// 文件级兜底：任何用例失败都不许把翻译子进程留下撑住 event loop
+test.after(() => {
+  const pidFile = process.env.MV3_TX_PIDFILE
+  if (!pidFile || !existsSync(pidFile)) return
+  const pid = readFileSync(pidFile, 'utf8').trim()
+  if (/^\d+$/.test(pid)) { try { process.kill(+pid, 'SIGKILL') } catch { /* 已退出 */ } }
+})
+
+/* ── 入口 5：创建/删除对称 + 畸形体 + 历史遗留名（PR-1 三处收口） ──────────── */
+test('V5 创建/删除对称（规范化路由名）、畸形 JSON 体 4xx、历史遗留专题名可删，`.trash` 是保留名', async (t) => {
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data5-'))
+  const base = await boot(DATA)
+  const post = async (p, obj, raw) => {
+    const r = await fetch(base + p, {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: raw !== undefined ? raw : JSON.stringify(obj),
+    })
+    const text = await r.text(); let body = null
+    try { body = JSON.parse(text) } catch { /* */ }
+    return { status: r.status, body, text }
+  }
+  // 畸形体：一律可读 4xx，不能是外层兜底 500，不能带堆栈
+  for (const raw of ['{ not json', 'null', '"str"', '[1,2]', '', 'undefined']) {
+    for (const p of [CANON.deletePaper, CANON.deleteTopic, CANON.renamePaper, CANON.renameTopic]) {
+      const r = await post(p, null, raw)
+      assert.ok(r.status >= 400 && r.status < 500, `${p} 畸形体 ${JSON.stringify(raw)} → ${r.status}（必须 4xx）`)
+      assert.ok(typeof r.body?.code === 'string', `${p} 必须带 code：${r.text.slice(0, 120)}`)
+      assert.ok(!/at .*\.js:\d+/.test(r.text), '响应不得含堆栈')
+    }
+  }
+  // 命名不规范的创建一律 4xx；**凡能创建的必然能删掉**（对称性）
+  for (const bad of ['.hidden', 'a'.repeat(300), 'x\u0000y', 'a/b', '..', '', '   ']) {
+    const r = await post('/api/library/topic', { name: bad })
+    assert.ok(r.status >= 400 && r.status < 500, `创建 ${JSON.stringify(bad)} 必须 4xx`)
+    assert.equal(r.body.code, 'bad-name')
+  }
+  const created = ['sym-a', '点号.名', 'with space', 'UPPER_case-1', '中文专题']
+  for (const name of created) {
+    const c = await post('/api/library/topic', { name })
+    assert.equal(c.status, 200, `创建 ${JSON.stringify(name)}：${c.text}`)
+    const d = await post(CANON.deleteTopic, { topic: name, confirmName: name })
+    assert.equal(d.status, 200, `能创建的 ${JSON.stringify(name)} 必须能用规范化路由名删掉：${d.text}`)
+    assert.ok(!existsSync(join(DATA, name)))
+  }
+  // 历史遗留（写入路径造不出来）的专题名必须能删；`.trash` 不能当专题删/改名
+  mkdirSync(join(DATA, '.legacy'), { recursive: true })
+  // 0x00-0x1F 能否落在文件名里是**文件系统能力**（Win32 路径层直接 ENOENT）→ 实测决定跑不跑这半段，
+  // 不硬编码平台（CI run 38193897047 的 V5 就是这条 mkdir 报 ENOENT）。
+  const ctrlName = canStoreControlName(DATA) ? 'weird\u0001name' : null
+  if (ctrlName) mkdirSync(join(DATA, ctrlName), { recursive: true })
+  else t.diagnostic('本机文件系统禁止 0x01 出现在文件名里（Win32 路径层）→ 跳过「控制字符历史专题名」半段，其余断言照跑')
+  assert.equal((await post(CANON.deleteTopic, { topic: '.legacy', confirmName: '.legacy' })).status, 200)
+  if (ctrlName) assert.equal((await post(CANON.deleteTopic, { topic: ctrlName, confirmName: ctrlName })).status, 200)
+  mkdirSync(join(DATA, '.trash'), { recursive: true })
+  const tr = await post(CANON.deleteTopic, { topic: '.trash', confirmName: '.trash' })
+  assert.equal(tr.status, 400); assert.equal(tr.body.code, 'bad-name')
+  assert.ok(existsSync(join(DATA, '.trash')), '回收站目录本身绝不能被当专题删掉')
+  // 非空专题：409 topic-not-empty，且 confirmName 必须一致（UI 两段式确认接的是我们的删除计划）
+  scaffold(DATA, 'nonempty', 'P')
+  // confirmName 在 delete-topic 上是**可选**栅栏（契约：host.ts:688-698）：给了才校验一致性；
+  // 没给就照走全部前置 → 非空专题一律 409 topic-not-empty（我们的加固，比上游「一点递归删光」保守）。
+  // 重排到合并后的 main 时这里是本功能唯一一处与现行契约不符的期望值（旧写成 400 confirm-mismatch）。
+  const noConfirm = await post(CANON.deleteTopic, { topic: 'nonempty' })
+  assert.equal(noConfirm.status, 409, noConfirm.text); assert.equal(noConfirm.body.code, 'topic-not-empty')
+  assert.ok(existsSync(join(DATA, 'nonempty', 'P.pdf')), '被拒时一个文件都不能动')
+  const mismatch = await post(CANON.deleteTopic, { topic: 'nonempty', confirmName: 'NonEmpty' })
+  assert.equal(mismatch.status, 400); assert.equal(mismatch.body.code, 'confirm-mismatch')
+  assert.ok(existsSync(join(DATA, 'nonempty', 'P.pdf')), '被拒时一个文件都不能动')
+  const nonEmpty = await post(CANON.deleteTopic, { topic: 'nonempty', confirmName: 'nonempty' })
+  assert.equal(nonEmpty.status, 409); assert.equal(nonEmpty.body.code, 'topic-not-empty')
+  assert.ok(existsSync(join(DATA, 'nonempty', 'P.pdf')), '被拒时一个文件都不能动')
+})
+
+/* ── 入口 6：移动失败时不销毁数据（「失败不回退 unlink」） ──────────────────── */
+test('V6 回收站移动失败：报错且**一个文件都不少**（绝不回退成 unlink 销毁）', async (t) => {
+  if (process.getuid && process.getuid() === 0) return t.skip('root 环境下目录只读无效')
+  const DATA = mkdtempSync(join(tmpdir(), 'dpr-mv3-data6-'))
+  scaffold(DATA, 'ro', 'Locked')
+  const base = await boot(DATA)
+  const before = snap(join(DATA, 'ro'))
+  // 注入方式按**本机实测**能力选（不硬编码平台）：
+  //   · chmod 0o555 真能挡住 rename 的平台（POSIX）：保留「中途失败」这条真实路径（原断言不变）；
+  //   · chmod 只映射只读位、挡不住 rename 的平台（Windows，CI run 38193897047 的 V6 就是它）：
+  //     换成**平台中立**注入 —— 把 `.trash` 写成普通文件，bundle 的 mkdir 必然 ENOTDIR 失败。
+  const chmodBlocks = chmodBlocksRename(DATA)
+  if (chmodBlocks) chmodSync(join(DATA, 'ro'), 0o555) // 目录不可写 → rename 进回收站必然失败
+  else {
+    t.diagnostic('本机 chmod 不阻止 rename（Windows 只读位语义）→ 改用「.trash 是普通文件」的平台中立注入')
+    writeFileSync(join(DATA, '.trash'), 'not-a-directory')
+  }
+  try {
+    const r = await fetch(base + CANON.deletePaper, {
+      method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify({ topic: 'ro', name: 'Locked' }),
+    })
+    const text = await r.text()
+    assert.ok(r.status >= 400, `移动失败必须报错而不是假装成功：${r.status} ${text.slice(0, 160)}`)
+    let body = null
+    try { body = JSON.parse(text) } catch { /* 非 JSON 时上面的断言已经说话 */ }
+    assert.equal(body?.code, 'trash-move-failed', `失败必须带机器可读 code：${text.slice(0, 200)}`)
+  } finally {
+    if (chmodBlocks) chmodSync(join(DATA, 'ro'), 0o755)
+  }
+  assert.deepEqual(diffSnap(before, snap(join(DATA, 'ro'))), [], '失败路径上任何文件都不许消失/被改（不得回退成 unlink）')
+  assert.ok(existsSync(join(DATA, 'ro', 'Locked.pdf')), '文献本体必须还在')
+})
diff --git a/test/merge-verify-t3.test.mjs b/test/merge-verify-t3.test.mjs
new file mode 100644
index 0000000..1b66f1b
--- /dev/null
+++ b/test/merge-verify-t3.test.mjs
@@ -0,0 +1,613 @@
+// test/merge-verify-t3.test.mjs — t3「独立验证」的复现用例：**翻页模式 × 公式热区**（全新渲染路径）
+//
+// 为什么单独一份、而不并入既有用例（方法独立性）：
+//   既有 reader-ux 系列与实现方 t2 的用例都用**手写 viewport stub**（{width:612*scale}）。
+//   本文件用**真实 pdf.js（pdfjs-dist，项目依赖）**对真实形状的 PDF 页调用 getViewport({scale})，
+//   期望矩形由本文件**独立复算**（bbox/1000 × viewport），再用「DOM 上真实落下去的 .eq-box 的几何中心」
+//   反查 hitTestFormula 闭环。bbox/LaTeX 夹具逐字取自真实 MinerU 产物（见 FIXTURE 里的 sha256/来源）。
+//
+// 覆盖：
+//   R1 翻页模式：① 热区层存在（结构）② bbox→viewport 独立复算（scale 1.0 / 1.5）③ 中心自命中闭环
+//   R2 换页清理：旧页几何与悬停态必须作废（防命中整体偏移）
+//   R3 切回滚动模式：全量页、每页一层、`paged` 类摘除、几何与命中仍正确
+//   R4 划词 vs 点击（两种模式）：热区**内部**起手拖选 → 引用文字；零位移点击 → 引用 LaTeX（紧凑形）
+//   R5 译文视图（-zh/-dual）在两种模式下关热区
+//   R6 结构契约：pointer-events:none、唯一铺层点在 paintPage、DOM id 与脚本引用配对、热区层不是 textLayer 容器
+//   R7 变异自检：R1/R2/R6 的断言对**注入缺陷**敏感（不是恒真断言）
+//
+// 只 import dist/*.js 与 reader/index.html；不写任何文献库文件。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { readFileSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { normalizeEol, extractModuleScript } from './reader-script.mjs'
+import vm from 'node:vm'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const dist = (m) => join(ROOT, '..', 'dist', m)
+// 行尾归一化后再取脚本：Windows 检出是 CRLF，按 LF 写死的正则会 `null[1]` 崩掉整个文件
+// （main 的守卫 C4/C5 口径，见 test/reader-script.mjs）
+const READER_HTML = normalizeEol(readFileSync(join(ROOT, '..', 'reader', 'index.html'), 'utf8'))
+const SCRIPT_SRC = extractModuleScript(READER_HTML, { where: 'reader/index.html' })
+
+const { buildFormulaIndex, compactLatex } = await import(pathToFileURL(dist('formulas.js')).href)
+
+/* ── 夹具：真实 MinerU 产物的 equation（bbox + LaTeX 逐字），见 .probe/merge-verify/11-real-equation-fixture.json ── */
+const FIXTURE = {
+ "sha256": "30f78ea8d261cdc3a5ca5dff1869f3d2953e25c270de79b9a61beadeaccf3601",
+ "source": "Hansen et al. - 2024 - TD-MPC2 ....mineru.json",
+ "items": [
+  {
+   "type": "equation",
+   "img_path": "images/47266377dfe59af4ed4c6da7e4e901ffa9b51199b56136712c3b5a2e59371cb0.jpg",
+   "text": "$$\n\\pi ( \\mathbf { s } _ { t } ) = \\arg \\operatorname* { m a x } _ { \\mathbf { a } _ { t : t + H } } \\mathbb { E } \\left[ \\sum _ { i = 0 } ^ { H } \\gamma ^ { t + i } R ( \\mathbf { s } _ { t + i } , \\mathbf { a } _ { t + i } ) \\right] .\\tag{1}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    338,
+    199,
+    658,
+    241
+   ],
+   "page_idx": 2
+  },
+  {
+   "type": "equation",
+   "img_path": "images/42d6609e0d01b036ebd315eae7e8819726b809fcb5f32f4fe77aaa5dde5bed56.jpg",
+   "text": "$$\n{ \\begin{array} { r l l } { { \\mathrm { E n c o d e r } } } & { \\mathbf { z } = h ( \\mathbf { s } , \\mathbf { e } ) } & { { \\mathrm { : } } { \\mathrm { ~ N a p s ~ o b s e r v a t i o n s ~ t o ~ t h e i r ~ l a t e n t ~ r e p r e s e n t a t i o n s } } } \\\\ { { \\mathrm { L a t e n t ~ d y n a m i c s } } } & { \\mathbf { z } ^ { \\prime } = d ( \\mathbf { z } , \\mathbf { a } , \\mathbf { e } ) } & { { \\mathrm { : } } { \\mathrm { ~ N o d e l s ~ ( l a t e n t ) ~ f o r w a r d ~ d y n a m i c s } } } \\\\ { { \\mathrm { R e w a r d } } } & { \\hat { r } = R ( \\mathbf { z } , \\mathbf { a } , \\mathbf { e } ) } & { { \\mathrm { : } } { \\mathrm { ~ P r e d i c t s ~ r e w a r d ~ r ~ o f ~ a ~ t r a n s i t i o n } } } \\\\ { { \\mathrm { T e r m i n a l ~ v a l u e } } } & { { \\hat { q } } = Q ( \\mathbf { z } , \\mathbf { a } , \\mathbf { e } ) } & { { \\mathrm { : } } { \\mathrm { ~ P r e d i c t s ~ d i s c o u n t e d ~ s u m ~ o f ~ r e w a r d s ~ ( r e t u r n ) } } } \\\\ { { \\mathrm { P o l i c y ~ p r i o r } } } & { { \\hat { \\mathbf { a } } } = p ( \\mathbf { z } , \\mathbf { e } ) } & { { \\mathrm { : } } { \\mathrm { ~ P r e d i c t s ~ a c t i o n ~ a ^ * ~ t h a t ~ m a x i m i z e s ~ } } Q } \\end{array} }\\tag{2}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    199,
+    820,
+    776,
+    893
+   ],
+   "page_idx": 2
+  },
+  {
+   "type": "equation",
+   "img_path": "images/f4fed7bc5e24dd5ed139eaa499b9fc64a06baa8b0cf8a3c13aa2f1f6d2a03953.jpg",
+   "text": "$$\n\\mathcal { L } \\left( \\boldsymbol { \\theta } \\right) \\doteq \\underset { ( \\mathbf { s } , \\mathbf { a } , r , \\mathbf { s } ^ { \\prime } ) _ { 0 : \\boldsymbol { H } } \\sim \\mathcal { B } } { \\mathbb { E } } \\left[ \\sum _ { t = 0 } ^ { H } \\lambda ^ { t } \\left( \\underset { \\mathrm { J o i n : e n b e d d i n g ~ p r e d i c i o n } } { \\parallel \\mathbf { z } _ { t } ^ { \\prime } - \\mathbf { s g } ( h ( \\mathbf { s } _ { t } ^ { \\prime } ) ) \\parallel _ { 2 } ^ { 2 } } + \\underset { \\mathrm { R e w a r d ~ p r e d i c i o n } } { \\mathbf { C } \\mathbf { E } ( \\hat { r } _ { t } , r _ { t } ) } + \\underset { \\mathrm { V a l u e ~ p r e d i c i o n } } { \\mathbf { C } \\mathbf { E } ( \\hat { q } _ { t } , q _ { t } ) } \\right) \\right] ,\\tag{3}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    197,
+    183,
+    777,
+    238
+   ],
+   "page_idx": 3
+  },
+  {
+   "type": "equation",
+   "img_path": "images/8a23051c5bc685d70aebd64306f89d8f4f619026f96d1400d1ea019eb88935ad.jpg",
+   "text": "$$\n\\mathcal { L } _ { p } ( \\boldsymbol { \\theta } ) \\doteq \\underset { ( \\mathbf { s } , \\mathbf { a } ) _ { 0 } : \\boldsymbol { H } \\sim \\mathcal { B } } { \\mathbb { E } } \\left[ \\sum _ { t = 0 } ^ { H } \\lambda ^ { t } \\left[ \\alpha Q ( \\mathbf { z } _ { t } , p ( \\mathbf { z } _ { t } ) ) - \\beta \\mathcal { H } ( p ( \\cdot | \\mathbf { z } _ { t } ) ) \\right] \\right] , \\mathbf { z } _ { t + 1 } = d ( \\mathbf { z } _ { \\mathbf { t } } , \\mathbf { a } _ { \\mathbf { t } } ) , \\mathbf { z } _ { 0 } = h ( \\mathbf { s } _ { 0 } ) .\\tag{4}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    178,
+    375,
+    792,
+    416
+   ],
+   "page_idx": 3
+  },
+  {
+   "type": "equation",
+   "img_path": "images/445530d5cea1a8a91f6b8f0eb78147adc06a5388afdfe9184b893f149a4c7986.jpg",
+   "text": "$$\n\\mathbf { z } ^ { \\circ } \\doteq [ \\mathbf { g } _ { i } , \\ldots , \\mathbf { g } _ { L } ] , \\mathbf { g } _ { i } = \\frac { e ^ { \\mathbf { z } _ { i : i + V } / \\tau } } { \\sum _ { j = 1 } ^ { V } e ^ { \\mathbf { z } _ { i : i + V } / \\tau } } ,\\tag{5}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    352,
+    636,
+    642,
+    672
+   ],
+   "page_idx": 3
+  },
+  {
+   "type": "equation",
+   "img_path": "images/6e1e76fe5f81e268b671e8e3ed411f5729c432838ff947f76294b4e8f4c2128c.jpg",
+   "text": "$$\n\\mu ^ { * } , \\boldsymbol { \\sigma } ^ { * } = \\arg \\operatorname* { m a x } _ { ( \\mu , \\boldsymbol { \\sigma } ) } \\underset { ( \\mathbf { a } _ { t } , \\mathbf { a } _ { t + 1 } , \\ldots , \\mathbf { a } _ { t + H } ) \\sim \\mathcal { N } ( \\mu , \\boldsymbol { \\sigma } ^ { 2 } ) } { \\mathbb { E } } \\left[ \\gamma ^ { H } Q ( \\mathbf { z } _ { t + H } , \\mathbf { a } _ { t + H } ) + \\sum _ { h = t } ^ { H - 1 } \\gamma ^ { h } R ( \\mathbf { z } _ { h } , \\mathbf { a } _ { h } ) \\right] ,\\tag{6}\n$$",
+   "text_format": "latex",
+   "bbox": [
+    194,
+    886,
+    781,
+    928
+   ],
+   "page_idx": 3
+  }
+ ]
+}
+
+/** 由真实 equation 夹具拼出 /api/formulas 会返回给阅读器的那份索引（走真实服务端投射）。 */
+function realIndex() {
+  const contentList = FIXTURE.items.map((b, i) => ({
+    type: 'equation', text: b.text, text_format: 'latex', bbox: b.bbox, page_idx: b.page_idx, img_path: `images/x${i}`,
+  }))
+  return buildFormulaIndex(JSON.stringify({ v: 1, producer: 'mineru-local', backend: 'pipeline', pageCount: 5, contentList }))
+}
+
+/* ── 真实 pdf.js：真实 viewport 的**唯一**来源 ───────────────────────────────── */
+const pdfjs = await import('pdfjs-dist/legacy/build/pdf.mjs')
+/** 零依赖 N 页 letter(612×792) PDF。 */
+function buildPdf(pages) {
+  const objs = []; const pn = []; objs[0] = null; objs[1] = null; const cn = []
+  for (let i = 0; i < pages; i++) { pn.push(objs.length + 1); objs.push(null); cn.push(objs.length + 1); objs.push(null) }
+  const fn = objs.length + 1
+  objs.push('<< /Type /Font /Subtype /Type1 /BaseFont /Helvetica >>')
+  const set = (n, b) => { objs[n - 1] = b }
+  set(1, '<< /Type /Catalog /Pages 2 0 R >>')
+  set(2, `<< /Type /Pages /Kids [${pn.map((n) => `${n} 0 R`).join(' ')}] /Count ${pages} >>`)
+  for (let i = 0; i < pages; i++) {
+    set(pn[i], `<< /Type /Page /Parent 2 0 R /MediaBox [0 0 612 792] /Contents ${cn[i]} 0 R /Resources << /Font << /F1 ${fn} 0 R >> >> >>`)
+    const s = `BT /F1 14 Tf 72 720 Td (merge-verify fixture page ${i + 1}) Tj ET\n`
+    set(cn[i], `<< /Length ${s.length} >>\nstream\n${s}endstream`)
+  }
+  let out = '%PDF-1.4\n'; const off = []
+  for (let i = 0; i < objs.length; i++) { off.push(out.length); out += `${i + 1} 0 obj\n${objs[i]}\nendobj\n` }
+  const x = out.length
+  out += `xref\n0 ${objs.length + 1}\n0000000000 65535 f \n`
+  for (const o of off) out += `${String(o).padStart(10, '0')} 00000 n \n`
+  out += `trailer\n<< /Size ${objs.length + 1} /Root 1 0 R >>\nstartxref\n${x}\n%%EOF\n`
+  return Buffer.from(out, 'latin1')
+}
+const REAL_DOC = await pdfjs.getDocument({ data: new Uint8Array(buildPdf(5)) }).promise
+
+/* ── 自建 DOM stub（子节点真正连起来；选择器只实现阅读器用到的那几种） ────────── */
+function parsePart(part) {
+  const m = part.match(/^([a-zA-Z]*)((?:[.#][^.#\[]+|\[[^\]]+\])*)$/)
+  if (!m) return null
+  const o = { tag: m[1] ? m[1].toUpperCase() : null, id: null, classes: [], attrs: [] }
+  for (const t of m[2].match(/[.#][^.#\[]+|\[[^\]]+\]/g) || []) {
+    if (t[0] === '#') o.id = t.slice(1)
+    else if (t[0] === '.') o.classes.push(t.slice(1))
+    else {
+      const a = t.slice(1, -1).split('=')
+      o.attrs.push([a[0].replace(/^data-/, '').replace(/-([a-z])/g, (_, c) => c.toUpperCase()), a[1] ? a[1].replace(/^"|"$/g, '') : null])
+    }
+  }
+  return o
+}
+function matchesPart(el, o) {
+  if (!o) return false
+  if (o.tag && el.tagName !== o.tag) return false
+  if (o.id && el.id !== o.id) return false
+  for (const c of o.classes) if (!el.classList.contains(c)) return false
+  for (const [k, v] of o.attrs) {
+    if (v === null) { if (el.dataset[k] === undefined) return false } else if (String(el.dataset[k]) !== v) return false
+  }
+  return true
+}
+const matchesSel = (el, sel) => sel.trim().split(/\s+/).every((p) => matchesPart(el, parsePart(p)))
+const matchesLast = (el, sel) => { const p = sel.trim().split(/\s+/); return matchesPart(el, parsePart(p[p.length - 1])) }
+
+function makeEl(tag, doc) {
+  const el = {
+    tagName: (tag || 'div').toUpperCase(), id: '', dataset: {}, children: [],
+    textContent: '', value: '', disabled: false, onclick: null, _classes: new Set(),
+    style: { setProperty(k, v) { this[k] = v }, removeProperty(k) { delete this[k] }, getPropertyValue: () => '' },
+    classList: {
+      add: (...c) => c.forEach((x) => el._classes.add(x)),
+      remove: (...c) => c.forEach((x) => el._classes.delete(x)),
+      toggle: (c, on) => { const v = on === undefined ? !el._classes.has(c) : on; if (v) el._classes.add(c); else el._classes.delete(c); return v },
+      contains: (c) => el._classes.has(c),
+    },
+    appendChild(c) { el.children.push(c); c.parentNode = el; return c },
+    append(...cs) { cs.forEach((c) => el.appendChild(c)) },
+    remove() { const p = el.parentNode; if (p) p.children = p.children.filter((x) => x !== el) },
+    closest(sel) { let n = el; while (n) { if (matchesLast(n, sel)) return n; n = n.parentNode } return null },
+    focus() { doc.activeElement = el }, blur() { doc.activeElement = null }, select() {}, click() { el.onclick && el.onclick() },
+    addEventListener(t, h) { (el._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (el._handlers[t]) el._handlers[t] = el._handlers[t].filter((x) => x !== h) },
+    _handlers: {},
+    querySelector(s) { return doc.querySelectorAll(s).find((e) => el.contains(e)) ?? null },
+    querySelectorAll(s) { return doc.querySelectorAll(s).filter((e) => el.contains(e)) },
+    getBoundingClientRect() { return { left: 0, top: 0, right: 0, bottom: 0, width: 0, height: 0 } },
+    contains(o) { let n = o; while (n) { if (n === el) return true; n = n.parentNode } return false },
+    scrollIntoView() {}, getContext() { return {} }, setAttribute(k, v) { if (k === 'class') el.className = v; else el.dataset[k] = v },
+    get clientHeight() { return el._ch ?? 0 }, set clientHeight(v) { el._ch = v },
+    get clientWidth() { return el._cw ?? 0 }, set clientWidth(v) { el._cw = v },
+    scrollTop: 0, scrollHeight: 0,
+  }
+  Object.defineProperty(el, 'className', { get: () => [...el._classes].join(' '), set: (v) => { el._classes = new Set(String(v).split(/\s+/).filter(Boolean)) } })
+  Object.defineProperty(el, 'innerHTML', { get: () => el._html ?? '', set: (v) => { el._html = v; if (v === '') el.children = [] } })
+  Object.defineProperty(el, 'firstChild', { get: () => el.children[0] ?? null })
+  Object.defineProperty(el, 'lastChild', { get: () => el.children[el.children.length - 1] ?? null })
+  Object.defineProperty(el, 'parentNode', { get: () => el._parent ?? null, set: (v) => { el._parent = v } })
+  Object.defineProperty(el, 'parentElement', { get: () => el._parent ?? null })
+  return el
+}
+
+function loadReader({ script = SCRIPT_SRC, storageInit = null } = {}) {
+  const byId = new Map(); const created = []
+  const doc = {
+    activeElement: null, _handlers: {},
+    getElementById(id) { if (!byId.has(id)) { const e = makeEl('div', doc); e.id = id; byId.set(id, e) } return byId.get(id) },
+    createElement(tag) { const e = makeEl(tag, doc); created.push(e); return e },
+    querySelector(s) { return doc.querySelectorAll(s)[0] ?? null },
+    querySelectorAll(s) { return created.filter((e) => matchesSel(e, s)) },
+    body: null, documentElement: null,
+    addEventListener(t, h) { (doc._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (doc._handlers[t]) doc._handlers[t] = doc._handlers[t].filter((x) => x !== h) },
+    dispatch(t, ev) { for (const h of doc._handlers[t] || []) h(ev) },
+  }
+  doc.body = makeEl('body', doc); doc.documentElement = makeEl('html', doc)
+  const win = {
+    devicePixelRatio: 1, innerWidth: 1200, innerHeight: 900,
+    addEventListener() {}, getSelection: () => null,
+    matchMedia: () => ({ addEventListener() {}, removeEventListener() {} }),
+  }
+  const storage = new Map(storageInit ? Object.entries(storageInit) : []); const requests = []
+  const ctx = {
+    document: doc, window: win, navigator: {}, localStorage: { getItem: (k) => storage.get(k) ?? null, setItem: (k, v) => storage.set(k, String(v)), removeItem: (k) => storage.delete(k) },
+    location: { search: '' }, matchMedia: win.matchMedia,
+    setTimeout, clearTimeout, setInterval, clearInterval,
+    console, URLSearchParams, parseFloat, parseInt, isNaN,
+    fetch: (url, opts = {}) => { requests.push({ url, body: opts.body }); return Promise.resolve({ ok: true, status: 200, json: async () => ({ n: 1, topics: [], papers: [] }) }) },
+    Promise, Math, JSON, Object, Array, Number, String, Boolean, Error, RegExp, Date, Set, Map,
+    IntersectionObserver: class { observe() {} unobserve() {} disconnect() {} takeRecords() { return [] } },
+    pdfjsLib: { TextLayer: class { async render() {} }, GlobalWorkerOptions: {} },
+  }
+  ctx.globalThis = ctx
+  vm.createContext(ctx)
+  const pane = doc.getElementById('pdf-pane'); pane.clientHeight = 800; pane.clientWidth = 1000
+  const harness = `
+    ;globalThis.__t = {
+      EQ_BY_PAGE, eqGeom, hitTestFormula, eqHotEnabled, clearEqGeometry,
+      setEq: (i) => { eqIndex = i }, setVariant: (v) => { zhVariant = v },
+      setZoom: (z) => { zoomScale = z }, setPageMode: (m) => { pageMode = m },
+      setCurPage: (n) => { curPage = n }, setPdfDoc: (d) => { pdfDoc = d }, setCurrent: (c) => { current = c },
+      getAskSelection: () => askSelection, getAskPop: () => askPop,
+      renderPaged, renderAllPages, rerender,
+    };`
+  vm.runInContext(script + harness, ctx, { filename: 'reader-inline.js' })
+  return { t: ctx.__t, doc, byId, created, win, requests }
+}
+
+/** 真实 pdf.js 页 → 阅读器要的形状（viewport 真的来自 pdf.js）。 */
+const wrapPage = (p) => ({ getViewport: (o) => p.getViewport(o), render: () => ({ promise: Promise.resolve() }), getTextContent: () => p.getTextContent() })
+const realDocStub = { numPages: REAL_DOC.numPages, getPage: async (n) => wrapPage(await REAL_DOC.getPage(Math.min(n, REAL_DOC.numPages))) }
+
+const pagesIn = (R) => R.byId.get('pdf-pages').children.filter((c) => c.className === 'page')
+const boxesOf = (page) => page.children.find((c) => c.className === 'eqLayer')?.children ?? []
+const centerOf = (b) => ({ x: parseFloat(b.style.left) + parseFloat(b.style.width) / 2, y: parseFloat(b.style.top) + parseFloat(b.style.height) / 2 })
+
+const IDX = realIndex()
+const EQ_PAGES = [...new Set(IDX.equations.filter((e) => e.bbox).map((e) => e.page))].sort((a, b) => a - b)
+const ex0y = (exp) => exp[0].vp.height - 2
+
+/** 独立复算：bbox（页归一化 ×1000）→ 该页真实 viewport 下的 CSS 矩形（与实现无关）。 */
+async function expectedRects(pageNo, scale) {
+  const vp = (await REAL_DOC.getPage(pageNo)).getViewport({ scale })
+  return IDX.equations.filter((e) => e.page === pageNo && e.bbox).map((e) => ({
+    id: e.id, latex: e.latex,
+    x0: e.bbox[0] / 1000 * vp.width, y0: e.bbox[1] / 1000 * vp.height,
+    x1: e.bbox[2] / 1000 * vp.width, y1: e.bbox[3] / 1000 * vp.height, vp,
+  }))
+}
+function bootReader({ mode = 'paged', scale = 1, page = null } = {}) {
+  // 注意：pageMode 的**真实**初值来自 localStorage（reader:247），所以这里从存储注入，
+  // 而不是加载后再改内部变量——后者测不到"模式切换记忆"。
+  const R = loadReader({ storageInit: { 'dpr.pageMode': mode } })
+  assert.equal(R.t.EQ_BY_PAGE.size, 0)
+  R.t.setEq(IDX); R.t.setVariant(null); R.t.setZoom(scale)
+  R.t.setPdfDoc(realDocStub)
+  R.t.setCurrent({ topic: 'merge-verify', name: 'fixture' })
+  if (page) R.t.setCurPage(page)
+  return R
+}
+
+/* ═══ R1 · 翻页模式：热区层存在 + 坐标独立复算 + 命中闭环（两档缩放） ═══════════ */
+
+test('R1 翻页模式：热区层存在、bbox→viewport 独立复算（scale 1.0/1.5）、盒子中心自命中', async () => {
+  assert.ok(EQ_PAGES.length >= 2, '夹具必须覆盖至少两页（真实产物有 bbox 的页）')
+  for (const scale of [1.0, 1.5]) {
+    for (const pageNo of EQ_PAGES) {
+      const R = bootReader({ mode: 'paged', scale, page: pageNo })
+      await R.t.renderPaged()
+      const live = pagesIn(R)
+      assert.equal(live.length, 1, `翻页模式只渲染 curPage 一页（scale=${scale}）`)
+      const page = live[0]
+      assert.equal(+page.dataset.page, pageNo)
+      assert.ok(page.children.some((c) => c.className === 'eqLayer'), `scale=${scale} 页 ${pageNo} 必须铺上 .eqLayer（H1：翻页模式热区全哑）`)
+      assert.equal(page.children.filter((c) => c.className === 'eqLayer').length, 1, '只许一层（重复铺会覆盖 EQ_BY_PAGE）')
+      assert.equal(page.children[page.children.length - 1].className, 'eqLayer', '热区层追加在 textLayer 之后')
+      assert.equal(page.children[0].tagName, 'CANVAS', 'canvas 仍是 firstChild（paintPage 的取值前提）')
+      assert.equal(R.t.EQ_BY_PAGE.size, 1, 'EQ_BY_PAGE 只含当前页')
+
+      const boxes = boxesOf(page)
+      const exp = await expectedRects(pageNo, scale)
+      assert.equal(boxes.length, exp.length, `scale=${scale} 页 ${pageNo} 热区盒数 = 有 bbox 的公式数`)
+      for (const ex of exp) {
+        const b = boxes.find((x) => x.dataset.eqId === ex.id)
+        assert.ok(b, `缺 eq-box ${ex.id}`)
+        assert.ok(Math.abs(parseFloat(b.style.left) - Math.max(0, ex.x0)) < 1e-6, `${ex.id} left 必须 = bbox[0]/1000×viewport.width`)
+        assert.ok(Math.abs(parseFloat(b.style.top) - Math.max(0, ex.y0)) < 1e-6, `${ex.id} top 必须 = bbox[1]/1000×viewport.height`)
+        assert.ok(Math.abs(parseFloat(b.style.width) - Math.max(1, Math.min(ex.vp.width, ex.x1) - Math.max(0, ex.x0))) < 1e-6, `${ex.id} width 必须按 bbox 宽度复算`)
+        assert.ok(Math.abs(parseFloat(b.style.height) - Math.max(1, Math.min(ex.vp.height, ex.y1) - Math.max(0, ex.y0))) < 1e-6, `${ex.id} height 必须按 bbox 高度复算`)
+        // 闭环：DOM 盒子的几何中心 → hitTestFormula 必须命中同一条
+        const c = centerOf(b)
+        assert.equal(R.t.hitTestFormula({ target: page.children[0], clientX: c.x, clientY: c.y })?.eq?.id, ex.id,
+          `scale=${scale} 页 ${pageNo} ${ex.id} 盒子中心(${c.x.toFixed(1)},${c.y.toFixed(1)}) 必须自命中`)
+      }
+      assert.equal(R.t.hitTestFormula({ target: page.children[0], clientX: 2, clientY: ex0y(exp) }), null, '远离公式处不得误命中')
+    }
+  }
+})
+
+test('R2 翻页模式：换页后上一页几何与悬停态必须作废（防命中整体偏移）', async () => {
+  const [p1, p2] = EQ_PAGES
+  const R = bootReader({ mode: 'paged', scale: 1, page: p1 })
+  await R.t.renderPaged()
+  const page1 = pagesIn(R)[0]
+  const b1 = boxesOf(page1)[0]
+  const c1 = centerOf(b1)
+  assert.equal(R.t.hitTestFormula({ target: page1.children[0], clientX: c1.x, clientY: c1.y })?.eq?.id, b1.dataset.eqId, '换页前可命中')
+  assert.ok(R.t.EQ_BY_PAGE.has(p1))
+  R.t.setCurPage(p2)
+  await R.t.renderPaged()
+  assert.ok(!R.t.EQ_BY_PAGE.has(p1), '换页后旧页几何必须被清掉（clearEqGeometry）')
+  assert.ok(R.t.EQ_BY_PAGE.has(p2))
+  assert.equal(pagesIn(R).length, 1, '换页后 DOM 仍只有一页')
+  assert.ok(!R.byId.get('pdf-pages').children.includes(page1), '旧页节点已从容器摘除')
+  assert.equal(R.t.hitTestFormula({ target: page1.children[0], clientX: c1.x, clientY: c1.y }), null, '旧页/旧坐标不得再命中')
+  const page2 = pagesIn(R)[0]
+  const exp2 = await expectedRects(p2, 1)
+  assert.equal(boxesOf(page2).length, exp2.length, '新页热区按新页 bbox 重铺')
+})
+
+/* ═══ R3 · 切回滚动模式：与改造前一致 ═══════════════════════════════════════ */
+
+test('R3 切回滚动模式：全量页 + 每页一层热区 + 摘掉 paged 类 + 几何/命中仍正确', async () => {
+  const R = bootReader({ mode: 'paged', scale: 1, page: EQ_PAGES[0] })
+  await R.t.renderPaged()
+  const container = R.byId.get('pdf-pages')
+  assert.ok(container.classList.contains('paged'), '翻页模式：#pdf-pages 带 paged 类')
+  R.t.setPageMode('scroll')
+  await R.t.renderAllPages()
+  assert.ok(!container.classList.contains('paged'), '切回滚动必须摘掉 paged 类（H3：否则单页布局样式残留）')
+  assert.equal(pagesIn(R).length, REAL_DOC.numPages, '滚动模式渲染全量页')
+  for (const p of pagesIn(R)) assert.equal(p.children.filter((c) => c.className === 'eqLayer').length, 1, '每页各一层 .eqLayer')
+  assert.equal(R.t.EQ_BY_PAGE.size, REAL_DOC.numPages, 'EQ_BY_PAGE 覆盖全部页（无公式的页为空数组）')
+  let hit = 0
+  for (const pageNo of EQ_PAGES) {
+    const page = pagesIn(R).find((p) => +p.dataset.page === pageNo)
+    const boxes = boxesOf(page)
+    const exp = await expectedRects(pageNo, 1)
+    assert.equal(boxes.length, exp.length, `页 ${pageNo} 热区盒数`)
+    for (const ex of exp) {
+      const b = boxes.find((x) => x.dataset.eqId === ex.id)
+      assert.ok(b, `页 ${pageNo} 缺 ${ex.id}`)
+      assert.ok(Math.abs(parseFloat(b.style.left) - Math.max(0, ex.x0)) < 1e-6, `页 ${pageNo} ${ex.id} 几何复算`)
+      const c = centerOf(b)
+      assert.equal(R.t.hitTestFormula({ target: page.children[0], clientX: c.x, clientY: c.y })?.eq?.id, ex.id, `页 ${pageNo} ${ex.id} 中心自命中`)
+      hit++
+    }
+  }
+  assert.ok(hit >= FIXTURE.items.length, `滚动模式全部公式独立复算+自命中（命中 ${hit} 条）`)
+  assert.equal(boxesOf(pagesIn(R).find((p) => !EQ_PAGES.includes(+p.dataset.page))).length, 0, '无公式的页：铺了层但层里没有盒子')
+})
+
+/* ═══ R4 · 划词优先 / 公式引用（翻页 + 滚动） ═══════════════════════════════ */
+
+async function selectionScenario(mode) {
+  const pageNo = EQ_PAGES[0]
+  const R = bootReader({ mode, scale: 1, page: pageNo })
+  if (mode === 'paged') await R.t.renderPaged(); else await R.t.renderAllPages()
+  const page = pagesIn(R).find((p) => +p.dataset.page === pageNo)
+  const box = boxesOf(page)[0]
+  const c = centerOf(box)
+  const tl = page.children.find((x) => x.className === 'textLayer')
+  const span = makeEl('span', R.doc); tl.appendChild(span)
+
+  // (a) 在热区内部起手拖选正文 → 引用**文字**
+  R.win.getSelection = () => ({ toString: () => 'selected body text inside the hotspot', anchorNode: span, getRangeAt: () => ({ getBoundingClientRect: () => ({ bottom: 100 }) }) })
+  R.doc.dispatch('mousedown', { target: span, clientX: c.x, clientY: c.y })
+  R.doc.dispatch('mouseup', { target: span, clientX: c.x + 40, clientY: c.y + 6 })
+  await new Promise((r) => setTimeout(r, 30))
+  const sel = R.t.getAskSelection()
+  assert.equal(sel?.kind, 'text', `${mode}: 热区内拖选必须是文字引用（A7）`)
+  assert.equal(sel?.text, 'selected body text inside the hotspot')
+  assert.equal(R.byId.get('ask-pop').style.display, 'block', `${mode}: 划词浮层可见`)
+
+  // (b) 零位移点击（无选区）→ 引用公式，载荷是紧凑 LaTeX
+  R.win.getSelection = () => null
+  R.doc.dispatch('mousedown', { target: page.children[0], clientX: c.x, clientY: c.y })
+  R.doc.dispatch('mouseup', { target: page.children[0], clientX: c.x, clientY: c.y })
+  await new Promise((r) => setTimeout(r, 30))
+  const eqSel = R.t.getAskSelection()
+  assert.equal(eqSel?.kind, 'equation', `${mode}: 零位移点击热区 → 公式引用`)
+  const fx = FIXTURE.items.find((b) => compactLatex(b.text) === IDX.equations.find((e) => e.index === eqSel.equationIndex)?.latex)
+  assert.ok(fx, `${mode}: 引用的公式必须来自真实 MinerU 夹具`)
+  const compactStripped = compactLatex(fx.text).replace(/^\s*\$\$?/, '').replace(/\$\$?\s*$/, '').trim()
+  assert.equal(eqSel.latex, compactStripped, `${mode}: selectedText 里的 LaTeX 是「原文 → 紧凑函数 → 去 $$」的形态`)
+  assert.equal(eqSel.text, `$$ ${compactStripped} $$`, `${mode}: 引用串形态 '$$ <紧凑 LaTeX> $$'`)
+  assert.ok(!/\{\s+\w\s+\}/.test(eqSel.latex), `${mode}: 不得保留 MinerU 逐字符空格形态`)
+  R.byId.get('ask-input').value = '解释一下'
+  const before = R.requests.length
+  await R.byId.get('ask-send').onclick()
+  const body = JSON.parse(R.requests.slice(before).find((q) => String(q.url).includes('/api/ask')).body)
+  assert.equal(body.selectedText, eqSel.text, `${mode}: 进 /api/ask 的 selectedText 与引用串一致`)
+  assert.equal(body.kind, 'equation')
+  assert.equal(body.equationIndex, eqSel.equationIndex)
+
+  // (c) 位移 >4px 且无选区 → 不当作公式点击
+  R.win.getSelection = () => null
+  R.t.getAskPop().style.display = 'none'
+  R.doc.dispatch('mousedown', { target: page.children[0], clientX: c.x, clientY: c.y })
+  R.doc.dispatch('mouseup', { target: page.children[0], clientX: c.x + 40, clientY: c.y + 30 })
+  await new Promise((r) => setTimeout(r, 30))
+  assert.equal(R.t.getAskPop().style.display, 'none', `${mode}: 拖拽（>4px）不得被误判成公式点击`)
+  return R
+}
+
+test('R4 划词优先：翻页模式与滚动模式下，热区内部起手拖选仍引用文字、点击才引用 LaTeX', async () => {
+  await selectionScenario('paged')
+  await selectionScenario('scroll')
+})
+
+/* ═══ R5 · 译文视图关热区（两种模式） ═══════════════════════════════════════ */
+
+test('R5 译文视图（-zh/-dual）：两种模式下都不铺热区、命中恒 null，切回原文恢复', async () => {
+  for (const mode of ['paged', 'scroll']) {
+    const R = bootReader({ mode, scale: 1, page: EQ_PAGES[0] })
+    if (mode === 'paged') await R.t.renderPaged(); else await R.t.renderAllPages()
+    const pick = () => (mode === 'paged' ? pagesIn(R)[0] : pagesIn(R).find((p) => +p.dataset.page === EQ_PAGES[0]))
+    R.t.setVariant('zh'); await R.t.rerender()
+    assert.ok(!pick().children.some((c) => c.className === 'eqLayer'), `${mode}: 译文视图不得铺热区层`)
+    assert.equal(R.t.hitTestFormula({ target: pick().children[0], clientX: 100, clientY: 100 }), null, `${mode}: 译文视图命中恒 null`)
+    R.t.setVariant('dual'); await R.t.rerender()
+    assert.ok(!pick().children.some((c) => c.className === 'eqLayer'), `${mode}: 中英对照同样关热区`)
+    R.t.setVariant(null); await R.t.rerender()
+    assert.ok(pick().children.some((c) => c.className === 'eqLayer'), `${mode}: 切回原文热区恢复`)
+    const b = boxesOf(pick())[0]; const c = centerOf(b)
+    assert.equal(R.t.hitTestFormula({ target: pick().children[0], clientX: c.x, clientY: c.y })?.eq?.id, b.dataset.eqId, `${mode}: 恢复后仍可命中`)
+  }
+})
+
+/* ═══ R6 · 结构契约（静态） ═══════════════════════════════════════════════ */
+
+const fnBody = (name, script = SCRIPT_SRC) => {
+  const i = script.indexOf(`function ${name}(`)
+  assert.ok(i > 0, `缺少 ${name}`)
+  return script.slice(i, script.indexOf('\n}\n', i))
+}
+
+/** 结构判据（对**任意** reader 源码生效，方便变异自检复用同一份判据）。 */
+const checkLayerPointerEvents = (html) => {
+  assert.match(html, /\.eqLayer \{[^}]*pointer-events: none/, '.eqLayer 必须是 pointer-events:none（不得夺走 textLayer 拖拽选区）')
+  assert.ok(!/\.eq-box[^{]*\{[^}]*pointer-events:\s*auto/.test(html), '.eq-box 不得把 pointer-events 改回 auto')
+}
+const checkTranscribeRerender = (script) => {
+  const tr = script.slice(script.indexOf('async function transcribeWithMineru'))
+  assert.ok(tr.length > 0, '缺少 transcribeWithMineru')
+  assert.match(tr.slice(0, tr.indexOf('\n}\n')), /await rerender\(\)/, 'transcribeWithMineru 必须按当前模式重渲（H4）')
+}
+const checkSolePaintPoint = (script) => {
+  assert.match(fnBody('paintPage', script), /paintEqLayer\(div, viewport, \+div\.dataset\.page\)/, '唯一铺层点必须在 paintPage 里')
+  assert.ok(!/paintEqLayer\(/.test(fnBody('renderPaged', script)), 'renderPaged 不得自己再铺一层')
+  assert.ok(!/paintEqLayer\(/.test(fnBody('renderAllPages', script)), 'renderAllPages 不得自己铺层（旧调用点必须搬走）')
+  assert.ok(!/container: tl/.test(fnBody('renderAllPages', script)), 'renderAllPages 不得残留对循环外 tl 的引用（会第一页就 ReferenceError）')
+  assert.match(fnBody('renderPaged', script), /clearEqGeometry\(\)/, 'renderPaged 换页必须清几何')
+  assert.match(fnBody('renderAllPages', script), /container\.classList\.remove\('paged'\)/, 'renderAllPages 必须摘掉 paged 类')
+}
+
+test('R6 结构契约：pointer-events:none、唯一铺层点在 paintPage、全量重渲走 rerender、DOM id 配对、热区层不夺文本层', () => {
+  checkLayerPointerEvents(READER_HTML)
+  checkSolePaintPoint(SCRIPT_SRC)
+  checkTranscribeRerender(SCRIPT_SRC)
+  // DOM id ↔ 脚本引用必须配对（任一为 null → 脚本开头即死、整页白屏）
+  const ids = new Set([...READER_HTML.matchAll(/\bid="([^"]+)"/g)].map((m) => m[1]))
+  const used = new Set()
+  for (const m of SCRIPT_SRC.matchAll(/\$\(\s*.([A-Za-z0-9_-]+).\s*\)/g)) used.add(m[1])
+  for (const m of SCRIPT_SRC.matchAll(/getElementById\(\s*.([A-Za-z0-9_-]+).\s*\)/g)) used.add(m[1])
+  assert.deepEqual([...used].filter((x) => !ids.has(x)), [], '脚本引用了不存在的 DOM id')
+  // 翻页模式的 DOM 与键盘/翻页控件在位（上游特性）
+  for (const id of ['pager', 'page-prev', 'page-input', 'page-total', 'page-next', 'mode-toggle', 'ver', 'dl-btn', 'pdf-path', 'eq-toggle', 'eq-panel']) {
+    assert.ok(ids.has(id), `顶栏/翻页控件 #${id} 必须在位`)
+  }
+})
+
+/* ═══ R8 · 翻页控件/状态/键盘（上游特性可用性，交互级） ═══════════════════ */
+
+test('R8 翻页控件/状态/键盘：模式切换、页码输入、‹› 按钮禁用态、Space/←/→ 翻页、输入框不抢键', async () => {
+  const R = bootReader({ mode: 'paged', scale: 1, page: 1 })
+  const T = R.t
+  const modeBtn = R.byId.get('mode-toggle')
+  const next = R.byId.get('page-next')
+  const prev = R.byId.get('page-prev')
+  const input = R.byId.get('page-input')
+  await T.renderPaged()
+  // main 的 5fdc51d 把顶栏统一成 inline SVG 图标集：paged 模式显示 paged 图标（不再有 ▣/≣ 字形），
+  // 状态由「图标 + active + title」表达 —— 这里钉图标口径 + active。
+  const pagedIcon = modeBtn.innerHTML
+  assert.match(pagedIcon, /<svg class="ic"/, '翻页模式下模式按钮显示图标（main 的图标集）')
+  assert.match(modeBtn.title, /单页翻页/, 'title 必须说明当前是单页翻页')
+  assert.ok(modeBtn.classList.contains('active'), '翻页模式下模式按钮 active')
+  assert.equal(prev.disabled, true, '第一页时 ‹ 禁用')
+  assert.equal(next.disabled, false, '第一页时 › 可用')
+  assert.equal(input.value, 1, '页码输入框回写当前页')
+  assert.equal(R.byId.get('page-total').textContent, '/ ' + REAL_DOC.numPages, '总页数显示')
+  // › 按钮 → 下一页（走 goPage → renderPaged）
+  await next.onclick()
+  assert.equal(input.value, 2, '› 后页码 = 2')
+  assert.equal(T.EQ_BY_PAGE.size, 1, '翻页后仍只有当前页几何')
+  // ← 键盘翻页（target 不是输入框）
+  let prevented = 0
+  R.doc.dispatch('keydown', { target: { tagName: 'DIV' }, key: 'ArrowLeft', preventDefault: () => { prevented++ } })
+  await new Promise((r) => setTimeout(r, 10))
+  assert.equal(input.value, 1, 'ArrowLeft 回到第 1 页')
+  assert.ok(prevented >= 1, '翻页键必须 preventDefault（不滚动页面）')
+  // Space 在输入框聚焦时不得翻页（U:776 的守卫）
+  R.doc.dispatch('keydown', { target: { tagName: 'INPUT' }, key: ' ', preventDefault: () => { prevented++ } })
+  await new Promise((r) => setTimeout(r, 10))
+  assert.equal(input.value, 1, '输入框里按 Space 不得翻页')
+  // 键盘 Home/End
+  R.doc.dispatch('keydown', { target: { tagName: 'DIV' }, key: 'End', preventDefault: () => {} })
+  await new Promise((r) => setTimeout(r, 10))
+  assert.equal(input.value, REAL_DOC.numPages, 'End 跳到末页')
+  assert.equal(next.disabled, true, '末页时 › 禁用')
+  // 模式切换 paged → scroll：全量页 + 摘掉 paged 类 + 按钮变 ≣
+  await modeBtn.onclick()
+  const container = R.byId.get('pdf-pages')
+  assert.equal(container.classList.contains('paged'), false, '切回滚动后 paged 类摘掉')
+  assert.equal(pagesIn(R).length, REAL_DOC.numPages, '切回滚动渲染全量页')
+  assert.match(modeBtn.innerHTML, /<svg class="ic"/, '滚动模式按钮同样显示图标')
+  assert.notEqual(modeBtn.innerHTML, pagedIcon, '滚动模式的图标必须与翻页模式不同（scroll ↔ paged）')
+  assert.match(modeBtn.title, /连续滚动/, 'title 必须说明当前是连续滚动')
+  assert.ok(!modeBtn.classList.contains('active'))
+  assert.equal(prev.disabled, false, '滚动模式下 ‹ 不禁用（禁用只属于翻页模式）')
+  assert.equal(next.disabled, false, '滚动模式下 › 不禁用')
+  // 滚动模式键盘不翻页
+  const before = input.value
+  R.doc.dispatch('keydown', { target: { tagName: 'DIV' }, key: 'ArrowRight', preventDefault: () => {} })
+  await new Promise((r) => setTimeout(r, 10))
+  assert.equal(input.value, before, '滚动模式下键盘不翻页')
+  // 再切回翻页：仍是单页渲染
+  await modeBtn.onclick()
+  assert.equal(container.classList.contains('paged'), true, '再切回翻页：paged 类回归')
+  assert.equal(pagesIn(R).length, 1, '再切回翻页：只渲染一页')
+})
+
+/* ═══ R7 · 变异自检：断言必须对注入缺陷敏感 ═══════════════════════════════ */
+
+test('R7 变异自检：把关键实现改坏，R1/R2/R6 的判据必须能抓到（断言不是恒真）', async () => {
+  const mutate = (from, to) => {
+    assert.ok(SCRIPT_SRC.includes(from), `变异锚点必须存在：${from}`)
+    return SCRIPT_SRC.replace(from, to)
+  }
+  const detect = async (script, check) => { try { await check(script); return null } catch (e) { return e } }
+
+  // M1：拿掉 paintPage 里的唯一铺层点 → 翻页模式必须"热区全哑"
+  const m1 = await detect(mutate('  paintEqLayer(div, viewport, +div.dataset.page);\n', ''), async (script) => {
+    const R = loadReader({ script }); R.t.setEq(IDX); R.t.setVariant(null); R.t.setZoom(1); R.t.setPageMode('paged')
+    R.t.setPdfDoc(realDocStub); R.t.setCurPage(EQ_PAGES[0]); await R.t.renderPaged()
+    assert.ok(pagesIn(R)[0].children.some((c) => c.className === 'eqLayer'), '铺层点被删后仍应失败')
+  })
+  assert.ok(m1, 'M1（删 paintEqLayer）必须被 R1 判据抓住')
+
+  // M2：renderPaged 里不清几何 → 换页后旧页几何残留
+  const m2 = await detect(mutate("  container.innerHTML = '';\n  clearEqGeometry(); // 同上：翻页模式下换页/缩放时，旧页几何与 hover 残留必须一起作废（否则命中整体偏移）\n", "  container.innerHTML = '';\n"), async (script) => {
+    const R = loadReader({ script }); R.t.setEq(IDX); R.t.setVariant(null); R.t.setZoom(1); R.t.setPageMode('paged')
+    R.t.setPdfDoc(realDocStub); R.t.setCurPage(EQ_PAGES[0]); await R.t.renderPaged()
+    R.t.setCurPage(EQ_PAGES[1]); await R.t.renderPaged()
+    assert.ok(!R.t.EQ_BY_PAGE.has(EQ_PAGES[0]), '未清几何时旧页仍应残留')
+  })
+  assert.ok(m2, 'M2（删 clearEqGeometry）必须被 R2 判据抓住')
+
+  // M3：把热区层改回会抢鼠标的覆盖层 → 结构契约必须失败
+  const EHR = '.eqLayer { position: absolute; inset: 0; pointer-events: none; z-index: 2; }'
+  const AHR = '.eqLayer { position: absolute; inset: 0; pointer-events: auto; z-index: 2; }'
+  assert.ok(READER_HTML.includes(EHR), 'M3 变异锚点必须存在于 reader/index.html 的 CSS 里')
+  const m3 = await detect(READER_HTML.replace(EHR, AHR), async (html) => { checkLayerPointerEvents(html) })
+  assert.ok(m3, 'M3（pointer-events:auto）必须被结构判据抓住')
+
+  // M4：transcribeWithMineru 改回全量重渲 → 结构契约必须失败
+  const m4 = await detect(mutate('    if (pdfDoc) await rerender();\n  } catch (e) {\n    toast(\'MinerU 转录失败', '    if (pdfDoc) await renderAllPages();\n  } catch (e) {\n    toast(\'MinerU 转录失败'), async (script) => { checkTranscribeRerender(script) })
+  assert.ok(m4, 'M4（transcribeWithMineru 用 renderAllPages）必须被结构判据抓住')
+
+  // M5：把唯一铺层点搬回 renderAllPages 的循环体（模拟"解冲突时选错落点"）→ 结构契约必须失败
+  const m5 = await detect(mutate('  paintEqLayer(div, viewport, +div.dataset.page);\n', ''), async (script) => { checkSolePaintPoint(script) })
+  assert.ok(m5, 'M5（拿掉 paintPage 里的唯一铺层点）必须被结构判据抓住')
+})
diff --git a/test/reader-render-guard.test.mjs b/test/reader-render-guard.test.mjs
new file mode 100644
index 0000000..95fc7fc
--- /dev/null
+++ b/test/reader-render-guard.test.mjs
@@ -0,0 +1,137 @@
+// test/reader-render-guard.test.mjs — 静态守卫：译文气泡的**公式渲染路径**
+//
+// 与 main 上那批守卫（windows-esm-guard / reader-script）同风格：扫源码、可本机跑、有变异验证。
+// 钉住三条不可退化的契约：
+//   R1 气泡渲染路径（showTrPop / trRenderBody / renderMathSegment / splitTranslatedMath / trComposeNote）
+//      **不得出现 innerHTML**（译文是模型输出，当不可信数据；文本段一律 textContent，数学段交 KaTeX 建 DOM）。
+//   R2 KaTeX 必须按契约参数调用：trust:false、throwOnError:false（真渲染）、strict:'ignore'，
+//      并且**探测那次**必须是 throwOnError:true，否则渲染失败抓不住、降级逻辑就成空转。
+//   R3 KaTeX 是本地 vendored 资源：页面用 **扁平** 路径 /paper-reader/vendor/<file> 引（不得引 CDN），
+//      且该路径形状必须与 host 路由的 `^[\w.-]+$` 白名单一致（子目录会让资源 400，见 pr7 诊断 P0）。
+//   R4 版本/许可证可追溯：NOTICE 与 vendored JS 的版本一致、LICENSE 是 MIT。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { existsSync, readFileSync, statSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
+import { normalizeEol, extractModuleScript } from './reader-script.mjs'
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..')
+const HTML = normalizeEol(readFileSync(join(REPO, 'reader', 'index.html'), 'utf8'))
+const SCRIPT = extractModuleScript(HTML, { where: 'reader/index.html' })
+const KATEX_DIR = join(REPO, 'reader', 'vendor')
+
+/** 取出一个顶层函数的源码（按大括号配对，字符串/注释/模板串原样保留）。 */
+function fnSource(src, name) {
+  const at = src.search(new RegExp(`\\nfunction\\s+${name}\\s*\\(`))
+  assert.ok(at >= 0, `源码里找不到 function ${name}()（守卫要跟着改，别静默失效）`)
+  const start = src.indexOf('{', at)
+  let depth = 0
+  let i = start
+  let kind = 'code'
+  while (i < src.length) {
+    const c = src[i]
+    const n = src[i + 1]
+    if (kind === 'code') {
+      if (c === '/' && n === '/') { kind = 'line'; i += 2; continue }
+      if (c === '/' && n === '*') { kind = 'block'; i += 2; continue }
+      if (c === '"' || c === "'" || c === '`') { kind = c; i += 1; continue }
+      if (c === '{') depth += 1
+      else if (c === '}') { depth -= 1; if (depth === 0) return src.slice(at, i + 1) }
+    } else if (kind === 'line') {
+      if (c === '\n') kind = 'code'
+    } else if (kind === 'block') {
+      if (c === '*' && n === '/') { kind = 'code'; i += 2; continue }
+    } else {           // 字符串/模板串
+      if (c === '\\') { i += 2; continue }
+      if (c === kind) kind = 'code'
+    }
+    i += 1
+  }
+  throw new Error(`function ${name}() 的大括号没有闭合`)
+}
+
+const RENDER_FNS = ['showTrPop', 'trRenderBody', 'renderMathSegment', 'splitTranslatedMath', 'trComposeNote']
+
+test('R1 气泡渲染路径不得出现 innerHTML（模型输出不可信）', () => {
+  const offenders = []
+  for (const name of RENDER_FNS) {
+    const body = fnSource(SCRIPT, name)
+    if (/\.innerHTML\b|\[['"]innerHTML['"]\]/.test(body)) offenders.push(name)
+  }
+  assert.deepEqual(offenders, [], `这些函数里出现了 innerHTML：${offenders.join(', ')}`)
+  // 正对照：同文件里别处确实有 innerHTML（不然这条守卫可能是空转）——限定在页代码里找一处已知用法
+  assert.match(SCRIPT, /container\.innerHTML\s*=\s*''/, '正对照失败：守卫的扫描目标可能已经不是页代码')
+})
+
+test('R2 KaTeX 调用参数必须是契约参数（且探测那次必须 throwOnError:true）', () => {
+  const body = fnSource(SCRIPT, 'renderMathSegment')
+  // 每个调用取「到分号为止」的实参文本（比整段正则稳）
+  const stmt = (call) => {
+    const at = body.indexOf(call)
+    assert.ok(at >= 0, `renderMathSegment 里找不到 ${call}`)
+    const end = body.indexOf(';', at)
+    assert.ok(end > at, `${call} 的语句没有分号结尾`)
+    return body.slice(at, end)
+  }
+  assert.equal((body.match(/k\.renderToString\(/g) ?? []).length, 1, '探测调用必须恰有一次')
+  assert.equal((body.match(/k\.render\(/g) ?? []).length, 1, '真渲染调用必须恰有一次')
+  const probe = stmt('k.renderToString(')
+  const real = stmt('k.render(')
+  for (const opts of [probe, real]) {
+    assert.match(opts, /trust:\s*false/, `必须 trust:false（不产原始 HTML）：${opts}`)
+    assert.match(opts, /strict:\s*'ignore'/, `必须 strict:'ignore'：${opts}`)
+  }
+  assert.match(real, /throwOnError:\s*false/, `真渲染必须 throwOnError:false：${real}`)
+  assert.match(probe, /throwOnError:\s*true/, `探测必须 throwOnError:true（否则抓不住失败、降级成空转）：${probe}`)
+  // 文本段必须走 textContent（只允许给新建元素赋 textContent）
+  const renderBody = fnSource(SCRIPT, 'trRenderBody')
+  assert.match(renderBody, /el\.textContent\s*=\s*seg\.text/, '文本段必须 textContent')
+  // 模式解析（P1 的核心）：探测用 throwOnError:true，且**失败要换另一种模式再试**（否则 \\tag 那批全降级）；
+  // 两个探测都必须是契约参数（trust:false / strict:'ignore'）。
+  const mode = fnSource(SCRIPT, 'resolveMathMode')
+  // 探测逻辑收敛在一个 probe() 里（一处 renderToString + 契约参数），调用两次：原模式 → 另一种模式
+  assert.equal((mode.match(/renderToString\(/g) ?? []).length, 1, 'resolveMathMode 的探测只应有一处 renderToString 调用')
+  assert.match(mode, /throwOnError:\s*true/, '探测必须 throwOnError:true（否则抓不住失败、无法换模式/降级）')
+  assert.match(mode, /trust:\s*false/, 'resolveMathMode 的探测也要 trust:false')
+  assert.match(mode, /strict:\s*'ignore'/, "resolveMathMode 的探测也要 strict:'ignore'")
+  assert.match(mode, /probe\(display\)/, '必须先按切分结果探测')
+  assert.match(mode, /probe\(!display\)/, '第一种模式失败后必须用**另一种**模式重试（display 取反）')
+})
+
+test('R3 KaTeX 必须是本地 vendored 资源（离线，不得引 CDN）', () => {
+  const tags = HTML.match(/<(?:link|script)[^>]*katex[^>]*>/g) ?? []
+  assert.equal(tags.length, 2, `页面应当恰好引 2 个 KaTeX 资源（CSS + JS）：${tags.join(' | ')}`)
+  for (const tag of tags) {
+    assert.ok(tag.includes('/paper-reader/vendor/'), `KaTeX 资源必须走本地路径：${tag}`)
+    assert.ok(!/https?:\/\//.test(tag), `不得引 CDN：${tag}`)
+    // 关键：URL 形状必须与 host 路由 `^[\w.-]+$` 白名单一致 —— 带子目录时资源会被 400 掉，
+    // 而这条正是 t18 漏掉的盲区（守卫只看磁盘、从不发 HTTP），见 docs/pr7-render-diagnosis.md P0。
+    const url = tag.match(/(?:href|src)="([^"]+)"/)?.[1] ?? ''
+    const name = url.replace('/paper-reader/vendor/', '')
+    assert.match(name, /^[\w.-]+$/, `KaTeX 资源名必须在路由白名单内（不能带子目录）：${url}`)
+  }
+  for (const f of ['katex.min.js', 'katex.min.css', 'katex.LICENSE', 'katex.NOTICE.md']) {
+    assert.ok(existsSync(join(KATEX_DIR, f)), `缺文件 reader/vendor/${f}`)
+  }
+  assert.ok(statSync(join(KATEX_DIR, 'katex.min.js')).size > 100_000, 'katex.min.js 体积异常（可能是占位文件）')
+  const css = readFileSync(join(KATEX_DIR, 'katex.min.css'), 'utf8')
+  // CSS 里的字体 URL 已随拉平改写为同目录（`url(KaTeX_X.woff2)`）——每个都得真实存在
+  const missing = [...css.matchAll(/url\(([A-Za-z0-9_.-]+\.woff2)\)/g)]
+    .map((m) => m[1])
+    .filter((f) => !existsSync(join(KATEX_DIR, f)))
+  assert.deepEqual(missing, [], `CSS 引用的字体必须都在（离线渲染要用）：${missing.join(', ')}`)
+})
+
+test('R4 版本与许可证可追溯（NOTICE 与 vendored JS 一致、LICENSE 是 MIT）', () => {
+  const js = readFileSync(join(KATEX_DIR, 'katex.min.js'), 'utf8')
+  const m = js.match(/version:"(\d+\.\d+\.\d+)"/)
+  assert.ok(m, 'katex.min.js 里读不到版本号')
+  const notice = readFileSync(join(KATEX_DIR, 'katex.NOTICE.md'), 'utf8')
+  assert.ok(notice.includes(m[1]), `NOTICE.md 的版本必须与 vendored JS 一致（JS=${m[1]}）`)
+  assert.ok(notice.includes('registry.npmjs.org/katex') && notice.includes('sha256'), 'NOTICE 必须写明来源 URL 与校验值')
+  const lic = readFileSync(join(KATEX_DIR, 'katex.LICENSE'), 'utf8')
+  assert.match(lic, /MIT License/, 'LICENSE 必须是 KaTeX 的 MIT 全文')
+  assert.match(lic, /Khan Academy/, 'LICENSE 必须保留上游版权声明')
+})
diff --git a/test/reader-vendor-http.test.mjs b/test/reader-vendor-http.test.mjs
new file mode 100644
index 0000000..ab1c251
--- /dev/null
+++ b/test/reader-vendor-http.test.mjs
@@ -0,0 +1,131 @@
+// test/reader-vendor-http.test.mjs — 阅读器静态资源**真发 HTTP** 取一遍（补 t18 的盲区）
+//
+// 为什么需要这个文件：t18 的守卫 R3 与 K6 都只看**磁盘**（readFileSync 灌 vm）⇒ 完全没发现
+// 「KaTeX 放在子目录、而 `/paper-reader/vendor/*` 路由只服务扁平文件名」这件事：磁盘上文件齐全、
+// 浏览器里三条 URL 全 400 ⇒ `window.katex` 不存在 ⇒ 每个数学段都降级（PR #7 的主因，见
+// docs/pr7-render-diagnosis.md 的 P0）。本文件用**发行产物** `dist/host.js` 起真 http server，
+// 把页面与 CSS 引到的每个资源逐个 GET，断言 200 + MIME + 内容真实。
+//
+// 同时钉住路由的**安全边界**（回归护栏）：嵌套路径、`..`、`%2e%2e%2f` 编码变形一律不得 200。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createServer, request as httpRequest } from 'node:http'
+import { mkdtempSync, readFileSync, rmSync } from 'node:fs'
+import { dirname, join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..')
+const dist = (m) => join(REPO, 'dist', m)
+
+/** 起一个真实的 host 路由服务器（与仓库既有路由用例同一手法：stub ctx + registerRoutes）。 */
+async function bootRoutes(dataDir) {
+  let spec = null
+  const ctx = {
+    webServer: { register: (s) => { spec = s; return () => {} } },
+    connection: { requestRejection: () => undefined },
+    sessionController: { list: async () => ({ items: [] }) },
+    workspaceController: {}, workspaceRegistry: {}, effect: (fn) => fn(),
+  }
+  const { registerRoutes } = await import(pathToFileURL(dist('host.js')).href)
+  registerRoutes(ctx, { dataDir })
+  const srv = createServer((req, res) => spec.handler(req, res))
+  await new Promise((r) => srv.listen(0, '127.0.0.1', r))
+  srv.unref?.()
+  return { base: `http://127.0.0.1:${srv.address().port}`, close: () => srv.close() }
+}
+
+test('V1 页面与 CSS 引到的每个 vendor 资源都必须真能 200（含 MIME）', async (t) => {
+  // dataDir 必须放**系统临时目录**：路由会按需创建它，放 test/ 下会在仓库里留一个目录，
+  // 而 reader-ux 的 VA16 会遍历 test/ 里的文件并 readFileSync（EISDIR，实测踩过）。
+  const D = mkdtempSync(join(tmpdir(), 'dpr-vendor-http-'))
+  t.after(() => rmSync(D, { recursive: true, force: true }))
+  const { base, close } = await bootRoutes(D)
+  try {
+    // ① 阅读器页面：拿到它引的两个 KaTeX 资源（CSS + JS）
+    const pageRes = await fetch(base + '/paper-reader/')
+    assert.equal(pageRes.status, 200, '阅读器页面必须 200')
+    const html = await pageRes.text()
+    // 静态标签（katex js/css）+ 脚本里动态 import 的（pdf.js 走 import('/paper-reader/vendor/pdf.min.mjs')）
+    const pageUrls = [...new Set([...html.matchAll(/<(?:link|script)[^>]*?(?:href|src)="(\/paper-reader\/vendor\/[^"]+)"/g)].map((m) => m[1])
+      .concat([...html.matchAll(/['"](\/paper-reader\/vendor\/[\w.-]+)['"]/g)].map((m) => m[1])))]
+    assert.ok(pageUrls.length >= 3, `页面必须至少引 3 个 vendor 资源（pdf.js ×2 + katex js/css）：${pageUrls}`)
+    assert.ok(pageUrls.includes('/paper-reader/vendor/katex.min.js') && pageUrls.includes('/paper-reader/vendor/katex.min.css'),
+      `KaTeX 必须以**扁平**路径引用（子目录会被路由 400）：${pageUrls}`)
+
+    // ② 逐个取页面引的资源：200 + 非空
+    for (const u of pageUrls) {
+      const r = await fetch(base + u)
+      assert.equal(r.status, 200, `${u} 必须 200（拿到 400/404 就会导致浏览器里 window.katex 不存在）`)
+      const buf = Buffer.from(await r.arrayBuffer())
+      assert.ok(buf.length > 100, `${u} 内容不像真资源（${buf.length} B）`)
+    }
+
+    // ③ KaTeX 的 JS/CSS 内容与 MIME 都要对（不是拿 200 的错误页糊弄）
+    const js = await fetch(base + '/paper-reader/vendor/katex.min.js')
+    assert.equal(js.headers.get('content-type'), 'text/javascript; charset=utf-8', 'KaTeX JS 必须是 text/javascript + charset')
+    assert.match(await js.text(), /version:"0\.16\.22"/, 'KaTeX JS 里必须能读出 0.16.22')
+    const css = await fetch(base + '/paper-reader/vendor/katex.min.css')
+    assert.equal(css.headers.get('content-type'), 'text/css; charset=utf-8', 'KaTeX CSS 必须是 text/css + charset')
+    const cssText = await css.text()
+
+    // ④ CSS 里引到的**每个** woff2 字体都必须真能取到（离线渲染的前提），且 MIME 是字体
+    const fonts = [...new Set([...cssText.matchAll(/url\(([A-Za-z0-9_.-]+\.woff2)\)/g)].map((m) => m[1]))]
+    assert.ok(fonts.length >= 10, `CSS 必须引到一组字体（拿到 ${fonts.length} 个）`)
+    for (const f of fonts) {
+      const r = await fetch(base + '/paper-reader/vendor/' + f)
+      assert.equal(r.status, 200, `字体 ${f} 必须 200（CSS 引了它，取不到就会退化成系统字体/乱码）`)
+      assert.equal(r.headers.get('content-type'), 'font/woff2', `字体 ${f} 的 MIME 必须**恰好**是 font/woff2（二进制资源不得追加 charset）`)
+      assert.ok(Buffer.from(await r.arrayBuffer()).length > 500, `字体 ${f} 内容太小`)
+    }
+  } finally { close() }
+})
+
+test('V2 路由安全边界：嵌套路径 / .. / 编码变形 一律不得 200（回归护栏）', async (t) => {
+  const D = mkdtempSync(join(tmpdir(), 'dpr-vendor-http-'))
+  t.after(() => rmSync(D, { recursive: true, force: true }))
+  const { base, close } = await bootRoutes(D)
+  try {
+    // 子目录形态：正是 PR #7 的 P0（资源在子目录 ⇒ 400）—— 这里把「路由不接受子目录」钉住，
+    // 这样一旦有人把 KaTeX 又放回子目录，本文件 + 守卫 R3 会一起红。
+    const nested = await fetch(base + '/paper-reader/vendor/katex/katex.min.js')
+    assert.equal(nested.status, 400, '子目录路径必须被路由拒绝（bad asset name）')
+    // 穿越与编码变形：一律 4xx，绝不能 200 拿到源码
+    // 注意：`fetch(base + p)` 会先做 URL 归一化（`..` 被吃掉、变成读页面），测不到服务端 ⇒ 这里用
+    // 原始 socket 请求把**字面路径**发出去。
+    const rawGet = (path) => new Promise((res) => {
+      const req = httpRequest({ host: '127.0.0.1', port: Number(new URL(base).port), path, method: 'GET' }, (r) => {
+        let body = ''
+        r.on('data', (c) => { body += c })
+        r.on('end', () => res({ status: r.statusCode, body }))
+      })
+      req.on('error', (e) => res({ status: 0, body: String(e) }))
+      req.end()
+    })
+    for (const p of ['/paper-reader/vendor/%2e%2e%2fhost.js', '/paper-reader/vendor/..%2f..%2fpackage.json',
+      '/paper-reader/vendor/sub%2Fkatex.min.js', '/paper-reader/vendor/%2E%2E%2Fkatex.min.js']) {
+      const r = await rawGet(p)
+      assert.ok(r.status >= 400 && r.status < 500, `${p} 必须是 4xx（拿到 ${r.status}；body=${r.body.slice(0, 60)}）`)
+      assert.ok(!/export const|"version"/.test(r.body), `${p} 不得泄漏仓库内容：${r.body.slice(0, 80)}`)
+    }
+    // 未编码的 `..`/`.`：node 的 URL 解析**在 dispatch 之前**就把路径归一化掉了（实测返回阅读器页面），
+    // 所以这里不断言状态码，只断言「没有得到 vendor 目录之外的文件内容」——不泄漏才是要点。
+    for (const p of ['/paper-reader/vendor/..', '/paper-reader/vendor/.', '/paper-reader/vendor/../package.json']) {
+      const r = await rawGet(p)
+      assert.ok(!/export const|"name": "|"version": "1\./.test(r.body), `${p} 不得泄漏仓库文件：${r.body.slice(0, 80)}`)
+    }
+    // 正常扁平名（带查询串）仍然可用
+    const ok = await fetch(base + '/paper-reader/vendor/katex.min.js?v=1')
+    assert.equal(ok.status, 200, '扁平文件名 + 查询串必须仍然 200')
+  } finally { close() }
+})
+
+test('V3 页面里 KaTeX 资源的 URL 形状与 host 白名单一致（静态核对，防再次放回子目录）', () => {
+  const html = readFileSync(join(REPO, 'reader', 'index.html'), 'utf8')
+  const urls = [...html.matchAll(/<(?:link|script)[^>]*?(?:href|src)="(\/paper-reader\/vendor\/[^"]+)"/g)].map((m) => m[1])
+  assert.ok(urls.length > 0, '页面必须引 vendor 资源')
+  for (const u of urls) {
+    assert.match(u, /^\/paper-reader\/vendor\/[\w.-]+$/, `资源 URL 必须与路由白名单 ^[\\w.-]+$ 同形：${u}`)
+  }
+})
diff --git a/test/selection-translate-verification.test.mjs b/test/selection-translate-verification.test.mjs
new file mode 100644
index 0000000..d3df615
--- /dev/null
+++ b/test/selection-translate-verification.test.mjs
@@ -0,0 +1,214 @@
+// test/selection-translate-verification.test.mjs — t3 独立验证的**补充复现测试**（审查方产出）
+//
+// 与 test/selection-translate.test.mjs（实现方自测）的分工：
+//   · 这里只固定「评审自己构造并亲自复现过」的事实：真实 .mineru.json 夹具、真实 PDF 的页数、
+//     以及 t3 报告里两个缺陷的**最小复现**（缺陷用例显式 skip，附带原因；修复后应把它们启用）。
+//   · 不 import 网络、不起浏览器、不写任何文献库文件；只用本机真实产物（缺失则 skip）。
+//
+// 复现命令：npm run build && node --test test/selection-translate-verification.test.mjs
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { existsSync, readFileSync } from 'node:fs'
+import { homedir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+
+const REPO = join(dirname(fileURLToPath(import.meta.url)), '..')
+const dist = (m) => join(REPO, 'dist', m)
+
+const { assembleSource, alignSelectionToBlock, stripJunk, formulaStatusOf, normForAlign } = await import(pathToFileURL(dist('translate-selection.js')).href)
+const { compactLatex, buildTextBlockIndex, buildFormulaIndex } = await import(pathToFileURL(dist('formulas.js')).href)
+
+const LIB = join(homedir(), '.dsh-paper-reader', 'data', '默认专题')
+const DONG = 'Dong et al. - 2026 - Language-Conditioned World Modeling for Visual Navigation'
+const HAS_DONG = existsSync(join(LIB, DONG + '.mineru.json'))
+const stripWs = (s) => s.replace(/\s+/g, '')
+
+/* ══ 1. 真实产物夹具：独立算出「该页含 $ 的 text 块」并按阅读序取用 ══════════ */
+const dongRaw = HAS_DONG ? readFileSync(join(LIB, DONG + '.mineru.json'), 'utf8') : null
+
+/** 本脚本自己的块表（按 contentList 顺序 + page_idx 缺失沿用上一块），与实现方的索引无关 */
+function myBlocks(pageNo) {
+  const parsed = JSON.parse(dongRaw)
+  const out = []
+  let last = 0
+  for (const b of parsed.contentList) {
+    if (typeof b.page_idx === 'number') last = b.page_idx
+    if (b.type !== 'text' || typeof b.text !== 'string' || !b.text.includes('$')) continue
+    if (last + 1 === pageNo) out.push(compactLatex(b.text))
+  }
+  return out
+}
+const page5Blocks = HAS_DONG ? myBlocks(5) : []
+const page6Blocks = HAS_DONG ? myBlocks(6) : []
+
+/* ══ 2. 组装链路：真机里实测到的三个选区形态（V1 亲自复现过，见 docs/selection-translate-verification.md） ══ */
+test('V1 行内单公式：/Conditions on navigation action ˆat/ → 公式被替换为紧凑 LaTeX（真实块夹具）', { skip: !HAS_DONG }, () => {
+  const r = assembleSource([{ page: 5, kind: 'text', text: 'conditions on navigation action ˆat' }], buildTextBlockIndex(dongRaw))
+  assert.equal(r.source, 'conditions on navigation action $\\hat{a}_t$')
+  assert.equal(r.applied, 1)
+})
+
+test('V2 行内多公式（跨两行、同一块）：4 个公式按序替换，正文逐字来自块（真实块夹具）', { skip: !HAS_DONG }, () => {
+  const text = 'Given current observations encoded as VAE latents,LCVN-WM Fθ conditions on navigation action ˆatwhere t denotes timestep, instruction I, and timeshift ts to predict the next state ˆst+1:'
+  const r = assembleSource([{ page: 5, kind: 'text', text }], buildTextBlockIndex(dongRaw))
+  assert.equal(
+    r.source,
+    'Given current observations encoded as VAE latents, LCVN-WM $F_\\theta$ conditions on navigation action $\\hat{a}_t$ where t denotes timestep, instruction I, and time shift $t_s$ to predict the next state $\\widehat s_{t+1}\\mathrm{:}$',
+  )
+  assert.deepEqual(r.source.match(/\$[^$]*\$/g), page5Blocks[0].match(/\$[^$]*\$/g))
+})
+
+test('V3 display 公式：formula chunk → `$紧凑LaTeX$`，乱码字符不进请求体', { skip: !HAS_DONG }, () => {
+  const idx = buildFormulaIndex(dongRaw)
+  const eq = idx.equations.find((e) => e.page === 6 && e.latex.includes('tag{4}') === false && e.latex.includes('\\begin{array}'))
+  assert.ok(eq, '第 6 页应有一个 array 型 display 公式')
+  const latex = eq.latex.replace(/^\s*\$\$?/, '').replace(/\$\$?\s*$/, '').trim()
+  const garbled = 'ˆsπt+1 ∼ Fθ (ˆsπt+1 | st, ˆat, Iclip, ts), (4)'   // 真实文本层乱码（含 \u0000 等）
+  const r = assembleSource([{ page: 6, kind: 'formula', latex }, { page: 6, kind: 'text', text: ' (4)' }], buildTextBlockIndex(dongRaw))
+  assert.ok(r.source.startsWith('$' + latex + '$'), 'display 公式原样包 $…$')
+  assert.ok(!r.source.includes('ˆsπt+1'), '乱码字形不得进入请求体')
+})
+
+test('V4 token 与 .mineru.json 原文只差空白（压紧过程不篡改内容）', { skip: !HAS_DONG }, () => {
+  const r = assembleSource([{ page: 5, kind: 'text', text: 'Given current observations encoded as VAE latents,LCVN-WM Fθ conditions' }], buildTextBlockIndex(dongRaw))
+  const toks = r.source.match(/\$[^$]*\$/g) ?? []
+  assert.ok(toks.length >= 1)
+  const rawBlock = page5Blocks[0]
+  for (const t of toks) assert.ok(stripWs(rawBlock).includes(stripWs(t.slice(1, -1))), `token ${t} 应能在块原文里找到（去空白后）`)
+})
+
+test('V5 组装文本不含 C0/C1、私用区、U+FFFD、走音符号（真实乱码夹具）', { skip: !HAS_DONG }, () => {
+  const r = assembleSource([{ page: 5, kind: 'text', text: 'si=Encθ(oi)\u02c6st+1\u0000\u0010\u0011 \ufffd \ue000\ue001 where t denotes timestep' }], buildTextBlockIndex(dongRaw))
+  const bad = [...r.source].filter((c) => {
+    const n = c.codePointAt(0)
+    return (n <= 0x1f && n !== 0x0a) || (n >= 0x7f && n <= 0x9f) || (n >= 0xe000 && n <= 0xf8ff) || n === 0xfffd || (n >= 0x300 && n <= 0x36f)
+  })
+  assert.deepEqual(bad, [])
+})
+
+test('V6 清洗边界：stripJunk 会吃掉 `^`（所以 LaTeX piece 必须绕开它），formula chunk 逐字保留', () => {
+  // 这就是 assembleSource 必须「按 piece 分类清洗」的原因：整段过 stripJunk 会把 v^\top 毁成 v\top。
+  assert.equal(stripJunk('a\u0000b^2 c'), 'ab2 c')
+  const r = assembleSource([{ page: 1, kind: 'formula', latex: 'v^\\top x^2' }], null)
+  assert.equal(r.source, '$v^\\top x^2$')
+})
+
+test('V7 无 MinerU 产物：原样返回 + formulaStatus=no-artifact（不假装还原）', () => {
+  const r = assembleSource([{ page: 1, kind: 'text', text: 'E = mc2 and πθ(a|s)' }], buildTextBlockIndex(null))
+  assert.equal(r.source, 'E = mc2 and πθ(a|s)')
+  assert.equal(r.applied, 0)
+  assert.equal(formulaStatusOf(r), 'no-artifact')
+})
+
+test('V8 极短选区（nf < 4）不对齐：原样返回且 skipped 计数', () => {
+  const r = assembleSource([{ page: 1, kind: 'text', text: 'πθ' }], buildTextBlockIndex(JSON.stringify({ contentList: [{ type: 'text', page_idx: 0, text: 'we use $\\pi_\\theta$ here' }] })))
+  assert.equal(r.source, 'πθ')
+  assert.equal(r.applied, 0)
+  assert.equal(r.skipped, 1)
+  assert.equal(formulaStatusOf(r), 'unavailable')
+})
+
+test('V9 跨页：两个 page 的 text chunk 各自成段，页间插 \\n（A14 的组装侧）', { skip: !HAS_DONG }, () => {
+  const a = assembleSource([
+    { page: 5, kind: 'text', text: 'conditions on navigation action ˆat' },
+    { page: 6, kind: 'text', text: 'where n denotes total trajectory length' },
+  ], buildTextBlockIndex(dongRaw))
+  assert.ok(a.source.includes('$\\hat{a}_t$'), '第 5 页的公式被还原')
+  assert.ok(a.source.includes('where n denotes total trajectory length'), '第 6 页的正文保留')
+  assert.equal(a.source.split('\n').length, 2, '页边界恰好一个 \\n')
+})
+
+test('V10 归一化只保留 [a-z0-9]+CJK（对口径的独立复算）', () => {
+  assert.equal(normForAlign('F_\\theta$ (ˆa_t)').A, 'fthetaat')
+})
+
+/* ══ 3. 分屏的两个纯函数（从 reader 内联脚本里原样抽出后求值，不改源码） ══════ */
+const READER = readFileSync(join(REPO, 'reader', 'index.html'), 'utf8')
+const fnSrc = (name) => {
+  const i = READER.indexOf(`function ${name}(`)
+  assert.ok(i > 0, `reader/index.html 里应有 function ${name}`)
+  let d = 0
+  for (let j = READER.indexOf('{', i); j < READER.length; j++) {
+    if (READER[j] === '{') d++
+    else if (READER[j] === '}') { d--; if (d === 0) return READER.slice(i, j + 1) }
+  }
+  throw new Error('unbalanced')
+}
+const mkFn = (name) => new Function(`${fnSrc(name)}; return ${name}`)()
+
+test('V11 anchorOf：顶部页号 + 页内比例（独立复算）', () => {
+  const anchorOf = mkFn('anchorOf')
+  const pages = [{ page: 1, offsetTop: 0, offsetHeight: 100 }, { page: 2, offsetTop: 100, offsetHeight: 200 }]
+  assert.deepEqual(anchorOf(pages, 0), { page: 1, ratio: 0 })
+  assert.deepEqual(anchorOf(pages, 150), { page: 2, ratio: 0.25 })
+  assert.deepEqual(anchorOf(pages, 100), { page: 2, ratio: 0 })
+  assert.deepEqual(anchorOf(pages, 999), { page: 2, ratio: 4.495 })
+  assert.equal(anchorOf([], 0), null)
+})
+
+test('V12 syncTargetOf：页数相同走同页号；页数不同按比例映射并置 mismatch（独立复算）', () => {
+  const syncTargetOf = mkFn('syncTargetOf')
+  const target = [{ page: 1, offsetTop: 0, offsetHeight: 120 }, { page: 2, offsetTop: 120, offsetHeight: 80 }]
+  assert.deepEqual(syncTargetOf({ page: 2, ratio: 0.5 }, target, 2), { top: 160, mismatch: false })
+  const m = syncTargetOf({ page: 1, ratio: 0.5 }, target, 3)
+  assert.equal(m.mismatch, true)
+  assert.equal(m.top, 60)
+})
+
+/* ══ 4. 真实 PDF 的变体页数（分屏同步的前提；B9 的夹具口径） ═══════════════ */
+test('V13 本机真实产物：原文 / -zh / -dual 页数与页面尺寸（-dual 恰 2× 页宽）', { skip: !existsSync(join(LIB, DONG + '-zh.pdf')) }, async () => {
+  const { getDocument } = await import('pdfjs-dist/legacy/build/pdf.mjs')
+  const stat = async (p) => {
+    const doc = await getDocument({ data: new Uint8Array(readFileSync(p)) }).promise
+    const vp = (await doc.getPage(1)).getViewport({ scale: 1 })
+    return { pages: doc.numPages, w: vp.width, h: vp.height }
+  }
+  const o = await stat(join(LIB, DONG + '.pdf'))
+  const z = await stat(join(LIB, DONG + '-zh.pdf'))
+  assert.deepEqual([o.pages, o.w, o.h], [19, 612, 792])
+  assert.deepEqual([z.pages, z.w, z.h], [19, 612, 792])
+  if (existsSync(join(LIB, DONG + '-dual.pdf'))) {
+    const d = await stat(join(LIB, DONG + '-dual.pdf'))
+    assert.deepEqual([d.pages, d.w], [19, 1224])
+  }
+})
+
+/* ══ 5. 原 t3 缺陷（attempt 2 复验：修复后已启用，全部通过） ══════════════
+   attempt 1 时这两条以 skip 记录「应有行为」；修复 commit（src/translate-selection.ts 12:59、
+   reader/index.html 12:58）后它们转为**必须通过**的回归用例：任何一次回退都会让全量测试变红。 */
+
+test('R2-F1 行内对齐不得丢掉跨度前的正文词（原 t3 F1，已修复）', { skip: !HAS_DONG }, () => {
+  const block = page6Blocks.find((b) => b.startsWith('where $\\mathbf{s}_t'))
+  assert.ok(block, '第 6 页应有以 `where $\\mathbf{s}_t` 开头的 text 块')
+  const r = alignSelectionToBlock('where st = [st, st−1, ..., st−k] denotes the sequence', block)
+  assert.equal(r.applied, 1)
+  assert.ok(r.text.startsWith('where '), `还原结果必须以块里的 "where" 开头，实际=${r.text}`)
+  assert.ok(r.text.includes('denotes the sequence'), `尾部正文也必须保留，实际=${r.text}`)
+  assert.ok(r.text.includes('$\\mathbf{s}_t='), `公式仍要还原成紧凑 LaTeX，实际=${r.text}`)
+})
+
+test('R2-F1b 带 display 公式编号前缀的同一形态（原 t3 S6 真机形态）', { skip: !HAS_DONG }, () => {
+  const block = page6Blocks.find((b) => b.startsWith('where $\\mathbf{s}_t'))
+  const r = alignSelectionToBlock(' (4)where st = [st, st−1, ..., st−k] denotes the sequence', block)
+  assert.equal(r.applied, 1)
+  assert.ok(r.text.startsWith('where '), `实际=${r.text}`)
+})
+
+test('R2-F2 选区所属段落不在候选集里时不得被别的段落接走（原 t3 F2，已修复）', { skip: !HAS_DONG }, () => {
+  // 该段落（During training, an expert encoder … while a learner encoder …）的块在**第 5 页**（跨页段落），
+  // 第 6 页候选块里没有它 ⇒ 必须原样返回（applied=0），而不是吐出别段落的 "expert and learner encoders"。
+  const r = assembleSource([{ page: 6, kind: 'text', text: ', while a learner encoder' }], buildTextBlockIndex(dongRaw))
+  assert.equal(r.source, ', while a learner encoder')
+  assert.equal(r.applied, 0)
+})
+
+test('R2-F2b 短碎片不得被错配（原 t3 F2 的同型反例，已修复）', { skip: !HAS_DONG }, () => {
+  const idx = buildTextBlockIndex(dongRaw)
+  for (const frag of [', while a learner encoder', 'During', 'training,', 'forcing (DF) (Chen et al., 2024; Song et al., 2025) to']) {
+    const r = assembleSource([{ page: 6, kind: 'text', text: frag }], idx)
+    assert.equal(r.source, frag, `短/跨页碎片 ${JSON.stringify(frag)} 必须原样返回`)
+    assert.equal(r.applied, 0)
+  }
+})
diff --git a/test/selection-translate.test.mjs b/test/selection-translate.test.mjs
new file mode 100644
index 0000000..8faa26b
--- /dev/null
+++ b/test/selection-translate.test.mjs
@@ -0,0 +1,2794 @@
+// test/selection-translate.test.mjs — 划词翻译（公式保留）+ 中英文分屏对照 的零依赖用例。
+//
+// 契约：docs/selection-translate-requirements.md（冻结 v1）§3.3–§3.9（服务端）与 §4（分屏）。
+// 只 import dist/*.js（跑前先 `npm run build`）+ vm 里跑**真实** reader 脚本。
+//
+// 覆盖（验收清单 A*/B* 里标「自动」的条目）：
+//   · 两条公式还原路径：**display 的 bbox 中心点相交**（客户端 formulaBoxByCenter/buildChunks）
+//     与**行内的文本对齐**（服务端 alignSelectionToBlock/assembleSource）
+//   · 多公式、部分重叠、对齐失败、无产物降级、跨页
+//   · 提示词逐字节契约、请求体字段集合、公式保全校验、缓存、失败分档
+//   · UI 结构性断言：译文气泡存在且零按钮、.eqLayer 仍 pointer-events:none、
+//     data-doc 作用域（中文列无热区/不污染 EQ_BY_PAGE）、模式切换的存储键
+//   · 分屏「同步滚动」开关（§G）：两处入口互相同步（阅读器 storage 事件 + 设置面板真渲染的组件）、
+//     全局记忆（不按篇、改名不丢）、默认开、关掉后各自独立滚动、重开对齐回当前页、模式 A 不受影响
+//
+// 全部零网络（上游用本机 mock HTTP），不触碰真实文献库（真实样本只**只读**读取）。
+
+import { test } from 'node:test'
+import assert from 'node:assert/strict'
+import { createServer } from 'node:http'
+import { existsSync, mkdirSync, mkdtempSync, readFileSync, readdirSync, rmSync, writeFileSync } from 'node:fs'
+import { homedir, tmpdir } from 'node:os'
+import { dirname, join } from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { normalizeEol, extractModuleScript } from './reader-script.mjs'
+import vm from 'node:vm'
+
+const ROOT = dirname(fileURLToPath(import.meta.url))
+const REPO = join(ROOT, '..')
+const dist = (m) => join(REPO, 'dist', m)
+
+const {
+  buildFormulaIndex, buildTextBlockIndex, compactLatex, resetFormulaCache,
+} = await import(pathToFileURL(dist('formulas.js')).href)
+const {
+  CACHE_LIMIT, MIN_NORM, SELECTION_SYSTEM_PROMPT,
+  SelectionTranslateError, TranslateSelectionCache,
+  alignSelectionToBlock, assembleSource, buildRequestBody, clampMaxTokens, formulaStatusOf,
+  formulaTokens, isLatexLikeFragment, normForAlign, selectionCache, selectionCacheKey,
+  stripFence, stripJunk, stripPrefix, translateSelection, verifyFormulas,
+} = await import(pathToFileURL(dist('translate-selection.js')).href)
+const { registerRoutes } = await import(pathToFileURL(dist('host.js')).href)
+
+// 行尾归一化后再取脚本：Windows 检出是 CRLF，按 LF 写死的正则会 `null[1]` 崩掉整个文件
+// （main 的守卫 C4/C5 口径，见 test/reader-script.mjs）
+const READER_HTML = normalizeEol(readFileSync(join(REPO, 'reader', 'index.html'), 'utf8'))
+const SCRIPT_SRC = extractModuleScript(READER_HTML, { where: 'reader/index.html' })
+
+/* ══════════════════════════════════════════════════════════════════════════
+   零依赖夹具：一份合成的 .mineru.json（3 个含行内公式的 text 块 + 1 个 equation）
+   ══════════════════════════════════════════════════════════════════════════ */
+
+const BLOCK_A = 'We define the probabilities that $x _ { t - 1 }$ transits to $x _ { t }$ using the matrices $[ Q _ { t } ] _ { m n } = q ( x _ { t } = m | x _ { t - 1 } = n ) \\in \\mathbb { R } ^ { K \\times K }$ . Then the forward Markov diffusion process can be written as,'
+const BLOCK_B = 'The policy $\\pi _ { \\theta } ( a | s )$ maximises the objective $J ( \\theta )$ over the dataset.'
+const BLOCK_C = 'On the next page, the value function $v _ { \\psi } ( s _ { t } , I )$ is learned by regression.'
+/** display 公式：客户端的乱码字符**已经不在**请求体里，服务端只负责包 `$` */
+const EQ_LATEX_RAW = '$$\nq ( x _ { t } | x _ { t - 1 } ) = v ^ { \\top } ( x _ { t } ) Q _ { t } v ( x _ { t - 1 } )\n$$'
+const EQ_LATEX = compactLatex(EQ_LATEX_RAW)          // 与 buildFormulaIndex 的投影同款
+const EQ_CITE = EQ_LATEX.replace(/^\s*\$\$?/, '').replace(/\$\$?\s*$/, '').trim()
+
+/** 文本层里的退化形态（实测形态：下标拉平、π/θ 变字形、大括号变控制字符）。 */
+const DEG_A = 'We define the probabilities that xt\u22121 transits to xt using the matrices [Qt]mn = q(xt = m|xt\u22121 = n) \u2208 RK\u00d7K. Then the forward Markov diffusion process can be written as,'
+const DEG_B = 'The policy \u03c0\u03b8(a|s) maximises the objective J(\u03b8) over the dataset.'
+const DEG_C = 'On the next page, the value function v\u03c8(st, I) is learned by regression.'
+/** 含真实控制字符/私用区的乱码公式块（A2 的夹具）：doc 里实测出现 \u0000/\u0010/\u0011 与私用区 */
+const JUNK_LINE = 'si=Enc\u03b8(oi)\u02c6st+1\u0000\u0010\u0011 \ufffd \ue000\ue001 where t denotes timestep'
+
+const FIXTURE_CONTENT_LIST = [
+  { type: 'text', page_idx: 0, bbox: [100, 200, 500, 260], text: BLOCK_A },
+  { type: 'text', page_idx: 0, bbox: [100, 300, 500, 360], text: BLOCK_B },
+  { type: 'equation', page_idx: 0, bbox: [150, 500, 400, 540], text: EQ_LATEX_RAW },
+  { type: 'text', page_idx: 1, bbox: [100, 200, 500, 260], text: BLOCK_C },
+  // 无 page_idx 的块：沿用上一个有页码的块（与既有投影口径一致）
+  { type: 'text', bbox: [100, 400, 500, 460], text: 'The reward $r _ { t }$ is bounded.' },
+]
+const FIXTURE_JSON = JSON.stringify({ producer: 'mineru', backend: 'pipeline', pageCount: 2, contentList: FIXTURE_CONTENT_LIST })
+
+const IDX = buildTextBlockIndex(FIXTURE_JSON)
+const NO_ARTIFACT = buildTextBlockIndex(null)
+
+/** 页面局部矩形（px）：中心点落在 equation 盒里 ⇔ 属于该公式。 */
+const eqItem = (id, x0, y0, x1, y1) => ({
+  eq: { id, page: 1, index: 0, latex: EQ_LATEX },
+  x0, y0, x1, y1, w: x1 - x0, h: y1 - y0, pad: 6,
+})
+const rect = (x0, y0, x1, y1) => [x0, y0, x1, y1]
+
+/* ══════════════════════════════════════════════════════════════════════════
+   A. 服务端：行内公式还原（文本对齐路径）
+   ══════════════════════════════════════════════════════════════════════════ */
+
+test('A3 行内还原：退化文本 ↔ 块文本对齐，产出带紧凑 LaTeX 的片段', () => {
+  const rA = alignSelectionToBlock(DEG_A, IDX.blocks[0].text)
+  assert.equal(rA.applied, 1, '同一行的退化文本必须能对齐回块文本')
+  assert.ok(rA.text.includes('$x_{t-1}$'), `必须还原第一个公式：${rA.text}`)
+  assert.ok(rA.text.includes('$x_t$'), '必须还原第二个公式')
+  assert.ok(rA.text.includes('$[Q_t]_{mn}=q(x_t=m|x_{t-1}=n)\\in\\mathbb{R}^{K\\times K}$'), '必须还原第三个（含 \\in/\\mathbb）')
+  assert.ok(rA.text.startsWith('We define the probabilities that '), '片段外正文必须保留')
+  assert.ok(rA.score >= 0.75, `接受阈值：score=${rA.score}`)
+  // 块文本**先过 compactLatex**（不是裸片段压缩）：块索引里已是紧凑形态
+  const raw = alignSelectionToBlock(DEG_B, IDX.blocks[1].text)
+  assert.ok(raw.text.includes('$\\pi_\\theta(a|s)$') && raw.text.includes('$J(\\theta)$'), `多公式：${raw.text}`)
+})
+
+test('A3-反面 对齐失败：与块文本无关的选区原样返回（applied=0，绝不猜）', () => {
+  const r = alignSelectionToBlock('this sentence appears nowhere in the parsed block at all', IDX.blocks[0].text)
+  assert.equal(r.applied, 0)
+  assert.equal(r.text, 'this sentence appears nowhere in the parsed block at all', '失败必须原样返回，不得截断正文')
+  // 极短选区：|nf| < 4 ⇒ skipped（A13 的判定依据）
+  const s = alignSelectionToBlock('F', IDX.blocks[1].text)
+  assert.equal(s.applied, 0)
+  assert.equal(s.skipped, true)
+  assert.equal(normForAlign('F').A.length, 1)
+  assert.ok(MIN_NORM === 4)
+})
+
+test('A3-反面 落单 $ / 长度越界：宁可原样返回也不给半个公式', () => {
+  // 长度保险：故意做一个「只匹配到很短的一小段」的选区（ratio 出界）
+  const long = 'On the next page, the value function v\u03c8(st, I) is learned by regression and then a lot of unrelated trailing words are appended here to break the length guard completely'
+  const r = alignSelectionToBlock(long, IDX.blocks[2].text)
+  if (r.applied === 1) {
+    assert.ok(!/[^$]\$[^$]*$/.test(r.text), `不得出现落单的 $：${r.text}`)
+    assert.equal((r.text.match(/\$/g) || []).length % 2, 0, `$ 必须成对：${r.text}`)
+  } else {
+    assert.ok(r.score === null || r.score < 1, '拒绝时不得伪造 score')
+  }
+})
+
+test('A4 四类选区：纯正文 / 纯行内 / 行内+display 混合 / 跨页（含跨块）', () => {
+  // ① 纯正文：能对齐的散文逐字节原样，且**不得引入任何 $**
+  const prose = assembleSource([{ page: 1, kind: 'text', text: 'Then the forward Markov diffusion process can be written as\n' }], IDX)
+  assert.equal(prose.source, 'Then the forward Markov diffusion process can be written as', `纯正文必须原样：${JSON.stringify(prose.source)}`)
+  assert.ok(!/\$/.test(prose.source))
+  // ①' 与候选块无关的散文：对齐失败，同样不得引入 $
+  const offBlock = assembleSource([{ page: 1, kind: 'text', text: 'This paragraph is not part of any parsed block at all\n' }], IDX)
+  assert.equal(offBlock.applied, 0)
+  assert.ok(!/\$/.test(offBlock.source), `对齐失败不得引入 $：${offBlock.source}`)
+
+  // ② 纯行内公式：整行都靠行内还原，还原后带 $
+  const inline = assembleSource([{ page: 2, kind: 'text', text: DEG_C }], IDX)
+  assert.ok(inline.source.includes('$v_\\psi(s_t,I)$'), `纯行内：${inline.source}`)
+  assert.equal(inline.applied, 1)
+
+  // ③ 行内 + display 混合：同一个文本流里两处都是 $…$，display 段来自 equation 的 latex
+  const mixed = assembleSource([
+    { page: 1, kind: 'text', text: DEG_B + '\n' },
+    { page: 1, kind: 'formula', latex: EQ_CITE },
+  ], IDX)
+  assert.ok(mixed.source.includes('$\\pi_\\theta(a|s)$'), `行内段来自对齐：${mixed.source}`)
+  assert.ok(mixed.source.includes('$' + EQ_CITE + '$'), `display 段来自 equation 的 latex：${mixed.source}`)
+  assert.equal(formulaTokens(mixed.source).length, 3, '两个行内 + 一个 display')
+
+  // ④ 跨块（同页两个 text 块各自命中自己的块）+ 跨页（页间插 \n，行尾换行保留）
+  const cross = assembleSource([
+    { page: 1, kind: 'text', text: DEG_A + '\n' },
+    { page: 1, kind: 'text', text: DEG_B + '\n' },
+    { page: 2, kind: 'text', text: DEG_C },
+  ], IDX)
+  assert.equal(cross.applied, 3, '跨块/跨页各自命中自己的块')
+  assert.ok(cross.source.includes('$\\pi_\\theta(a|s)$') && cross.source.includes('$x_{t-1}$'), `两块各自还原：${cross.source}`)
+  assert.ok(cross.source.includes('$x_t$ using the matrices'), '行尾换行不得吃掉下一段')
+  assert.ok(cross.source.includes('over the dataset\nOn the next page'), `页间必须有 \n：${JSON.stringify(cross.source)}`)
+  assert.equal(formulaStatusOf(cross), 'applied')
+  // 行结构：三行（三段各一行）——system 第 3 条要求保持行结构
+  assert.equal(cross.source.split('\n').length, 3)
+})
+
+test('A2 组装文本不含乱码字符类（C0/C1、私用区、U+FFFD、走音符号）', () => {
+  const junkRe = /[\u0000-\u001f\u007f-\u009f\ue000-\uf8ff\ufffd\u005e\u0060\u00b4\u02c6\u02dc\u0300-\u036f]/
+  const out = assembleSource([
+    { page: 1, kind: 'text', text: JUNK_LINE },
+    { page: 1, kind: 'formula', latex: 'F_\\theta' },
+  ], IDX)
+  assert.ok(!junkRe.test(out.source), `组装文本里不得出现乱码字符类：${JSON.stringify(out.source)}`)
+  assert.ok(!junkRe.test(out.source.replace(/\n/g, '')), '换行以外不得有一处乱码')
+  // stripJunk 直测：逐类字符都能清掉，且空白折叠成一个空格
+  assert.equal(stripJunk('a\u0000b\u0010c\u0011d\u007fe\u009ff\ue000g\ufffdh\u02c6i\u005ej\u0060k\u0301l'), 'abcdefghijkl')
+  assert.equal(stripJunk('a   b\t\tc'), 'a b c')
+  // 换行是结构（A14/system 第 3 条）：不得被折叠掉
+  assert.equal(stripJunk('a  \n\n  b'), 'a\nb')
+  assert.equal(stripJunk('  hi  '), 'hi')
+})
+
+test('A5 纯 display 选区：公式段整体来自 equation 的 latex，formulaTotal 由组装文本决定', () => {
+  const out = assembleSource([{ page: 1, kind: 'formula', latex: EQ_CITE }], IDX)
+  assert.equal(out.source, '$' + EQ_CITE + '$')
+  assert.equal(out.textChunkCount, 0)
+  assert.equal(formulaStatusOf(out), 'applied', 'textChunkCount===0 的纯 display 选区算 applied')
+  // 组装阶段的 formulaTotal 不是缓存字段：由 verifyFormulas 从源文本现算
+  const v = verifyFormulas(out.source, '中文译文 $' + EQ_CITE + '$')
+  assert.deepEqual([v.total, v.kept, v.lost], [1, 1, 0])
+})
+
+test('A8/R16 无 MinerU 产物降级：文本原样下发 + hasBlockIndex=false + no-artifact', () => {
+  const out = assembleSource([
+    { page: 1, kind: 'text', text: DEG_A },
+    { page: 1, kind: 'formula', latex: 'F_\\theta' },
+  ], NO_ARTIFACT)
+  assert.equal(out.hasBlockIndex, false)
+  assert.equal(out.applied, 0)
+  assert.ok(out.source.includes('DEG_A'.length ? 'xt\u22121' : ''), '无产物时退化文本原样下发（乱码可由 stripJunk 清掉，但不得编造公式）')
+  assert.ok(!out.source.includes('$x_{t-1}$'), '不得编造公式')
+  assert.equal(formulaStatusOf(out), 'no-artifact')
+  // 损坏产物（contentList 不是数组）同样降级
+  const bad = buildTextBlockIndex('{"contentList":"nope"}')
+  assert.deepEqual([bad.source, bad.reason], ['none', 'bad-artifact'])
+  assert.equal(formulaStatusOf(assembleSource([{ page: 1, kind: 'text', text: 'abc def ghi' }], bad)), 'no-artifact')
+})
+
+test('A13 极短选区：不对齐并回报 formulaSkipped（客户端据此出「选区太短」）', () => {
+  const out = assembleSource([{ page: 1, kind: 'text', text: 'F' }], IDX)
+  assert.equal(out.applied, 0)
+  assert.equal(out.skipped, 1)
+  assert.equal(formulaStatusOf(out), 'unavailable')
+  const partial = assembleSource([
+    { page: 1, kind: 'text', text: 'F' },
+    { page: 1, kind: 'text', text: DEG_B },
+  ], IDX)
+  assert.equal(partial.applied, 1)
+  assert.equal(partial.skipped, 1)
+  assert.equal(formulaStatusOf(partial), 'partial')
+})
+
+test('A15 规模闸门：请求体校验上限与 clampMaxTokens 公式', () => {
+  assert.equal(clampMaxTokens(10), 256)          // 下限
+  assert.equal(clampMaxTokens(100), 256)         // ceil(150)=150 → 下限 256
+  assert.equal(clampMaxTokens(1000), 1500)
+  assert.equal(clampMaxTokens(100000), 4096)     // 上限
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   B. 服务端：提示词契约 / 请求体 / 公式保全 / 失败分档 / 缓存 / key 不泄漏
+   ══════════════════════════════════════════════════════════════════════════ */
+
+test('A6 提示词逐字节冻结 + 请求体字段集合 + thinking 判据', () => {
+  const EXPECTED = [
+    'You are a professional, authentic machine translation engine for academic papers.',
+    'Translate the user\'s input into Simplified Chinese.',
+    '',
+    'Hard rules:',
+    '1. Any content wrapped in $...$ is a LaTeX formula. Keep every formula EXACTLY as',
+    '   given: do not translate it, do not rewrite or simplify it, do not change spaces,',
+    '   braces, or backslashes, do not drop it, do not add any.',
+    '2. Output the translation ONLY. No preamble, no explanation, no notes, no headings,',
+    '   no Markdown code fences, no quotes around the whole output.',
+    '3. Preserve the paragraph and line structure of the input. Never add content that is',
+    '   not in the input.',
+    '4. Translate terminology by field convention (policy -> 策略, world model -> 世界模型).',
+    '   Keep model names, dataset names, method names and abbreviations (LCVN-WM, DiT, CLIP)',
+    '   in the original form.',
+    '5. If the input is already Chinese, return it as is.',
+  ].join('\n')
+  assert.equal(SELECTION_SYSTEM_PROMPT, EXPECTED, 'system 必须与 §3.6 逐字节相同')
+
+  const src = 'translate $x_t$ here'
+  const body = buildRequestBody('deepseek-chat', src, 'https://api.deepseek.com/v1')
+  assert.deepEqual(Object.keys(body), ['model', 'messages', 'max_tokens', 'temperature', 'thinking'])
+  assert.deepEqual(Object.keys(buildRequestBody('m', src, 'https://api.openai.com/v1')), ['model', 'messages', 'max_tokens', 'temperature'])
+  assert.deepEqual(body.thinking, { type: 'disabled' })
+  assert.equal(body.model, 'deepseek-chat')
+  assert.equal(body.temperature, 0)
+  assert.equal(body.max_tokens, clampMaxTokens(src.length))
+  assert.deepEqual(body.messages, [
+    { role: 'system', content: SELECTION_SYSTEM_PROMPT },
+    { role: 'user', content: src },
+  ])
+  // 绝不发这些字段
+  for (const k of ['response_format', 'reasoning', 'tools', 'top_p', 'stream']) {
+    assert.ok(!(k in body), `请求体不得包含 ${k}`)
+  }
+})
+
+test('A7 公式保全校验：丢一个 $…$ → formulaLost=1 且能指认是哪一段', () => {
+  const src = 'a $x_t$ b $y_t$ c'
+  const v = verifyFormulas(src, '甲 $x_t$ 乙 丙')     // 模型漏了 $y_t$
+  assert.deepEqual([v.total, v.kept, v.lost], [2, 1, 1])
+  assert.deepEqual(v.missing, ['$y_t$'])
+  assert.deepEqual([...formulaTokens(src)], ['$x_t$', '$y_t$'])
+  // 完整保留时 lost=0
+  assert.equal(verifyFormulas(src, '甲 $x_t$ 乙 $y_t$ 丙').lost, 0)
+})
+
+test('A7-续 响应清洗：代码围栏与「译文：」前缀必须剥掉，不混进气泡正文', () => {
+  assert.equal(stripFence('```\n你好 $x_t$\n```'), '你好 $x_t$')
+  assert.equal(stripFence('```markdown\n你好\n```'), '你好')
+  assert.equal(stripFence('你好'), '你好', '无围栏时原样')
+  assert.equal(stripPrefix('译文：你好'), '你好')
+  assert.equal(stripPrefix('翻译: 你好'), '你好')
+  assert.equal(stripPrefix('Translation: hi'), 'hi')
+  assert.equal(stripPrefix('你好：世界'), '你好：世界', '只剥行首的固定前缀')
+})
+
+test('A10 失败分档：401/403、429、5xx、超时、网络失败 → 错误码与上游状态码齐备', async () => {
+  const ep = { baseUrl: 'https://example.invalid/v1', apiKey: 'sk-fake-key-0123456789', model: 'm' }
+  const mk = (status, text) => async () => ({ status, ok: false, text: async () => text })
+  const cases = [
+    [mk(401, '{"error":"bad key"}'), 'upstream', 502, 401],
+    [mk(403, 'forbidden'), 'upstream', 502, 403],
+    [mk(429, 'rate limited'), 'upstream', 502, 429],
+    [mk(500, 'boom'), 'upstream', 502, 500],
+  ]
+  for (const [fetchImpl, code, status, up] of cases) {
+    const err = await translateSelection(ep, 'x', { fetchImpl, cache: new TranslateSelectionCache() }).catch((e) => e)
+    assert.ok(err instanceof SelectionTranslateError, '必须抛 SelectionTranslateError')
+    assert.equal(err.code, code)
+    assert.equal(err.status, status)
+    assert.equal(err.upstreamStatus, up)
+    assert.ok(!err.message.includes('sk-fake-key-0123456789'), '错误文案不得含 key')
+  }
+  // 超时（AbortSignal 语义由注入的 fetch 模拟）
+  const timeoutErr = await translateSelection(ep, 'x', {
+    cache: new TranslateSelectionCache(),
+    timeoutMs: 20,
+    fetchImpl: () => new Promise((_, rej) => { const e = new Error('aborted'); e.name = 'TimeoutError'; rej(e) }),
+  }).catch((e) => e)
+  assert.equal(timeoutErr.code, 'timeout')
+  assert.equal(timeoutErr.status, 504)
+  // 网络失败
+  const netErr = await translateSelection(ep, 'x', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: () => { const e = new Error('fetch failed'); e.cause = new Error('ECONNREFUSED'); throw e },
+  }).catch((e) => e)
+  assert.equal(netErr.code, 'network')
+  assert.equal(netErr.status, 502)
+  assert.match(netErr.message, /ECONNREFUSED/, '必须把 cause 带进文案（否则用户看不出原因）')
+  // 端点不齐
+  const noEp = await translateSelection({ baseUrl: '', apiKey: '', model: '' }, 'x', {}).catch((e) => e)
+  assert.equal(noEp.code, 'no-endpoint')
+  assert.equal(noEp.status, 503)
+  // 响应不是补全结果 / content 为空
+  const notJson = await translateSelection(ep, 'x', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: async () => ({ status: 200, ok: true, text: async () => 'not json at all' }),
+  }).catch((e) => e)
+  assert.equal(notJson.code, 'upstream')
+  const emptyContent = await translateSelection(ep, 'x', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: async () => ({ status: 200, ok: true, text: async () => '{"choices":[{"message":{"content":"   "}}]}' }),
+  }).catch((e) => e)
+  assert.equal(emptyContent.code, 'upstream')
+})
+
+test('A10-续 唯一重试：HTTP 400 且体匹配 /temperature/ → 去掉 temperature 重发一次', async () => {
+  const seen = []
+  let first = true
+  const fetchImpl = async (_url, init) => {
+    seen.push(JSON.parse(init.body))
+    if (first) { first = false; return { status: 400, ok: false, text: async () => '{"error":"unsupported parameter: temperature"}' } }
+    return { status: 200, ok: true, text: async () => '{"choices":[{"message":{"content":"你好"}}]}' }
+  }
+  const r = await translateSelection({ baseUrl: 'https://x/v1', apiKey: 'k', model: 'm' }, 'hello', { fetchImpl, cache: new TranslateSelectionCache() })
+  assert.equal(r.translation, '你好')
+  assert.equal(seen.length, 2, '只允许重发一次')
+  assert.ok('temperature' in seen[0])
+  assert.ok(!('temperature' in seen[1]), '重发时必须去掉 temperature')
+  // 400 但不是 temperature 问题 → 不重试
+  const seen2 = []
+  const err = await translateSelection({ baseUrl: 'https://x/v1', apiKey: 'k', model: 'm' }, 'hello', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: async (_u, init) => { seen2.push(1); return { status: 400, ok: false, text: async () => '{"error":"bad model"}' } },
+  }).catch((e) => e)
+  assert.equal(seen2.length, 1, '非 temperature 的 400 不得重试（避免重复计费）')
+  assert.equal(err.upstreamStatus, 400)
+})
+
+test('A11 key 不泄漏：请求体/响应体/错误体都没有 key，日志白名单只有四个字段', async () => {
+  const key = 'sk-leak-canary-abcdefghijklmnop'
+  const logs = []
+  const fetchImpl = async () => ({ status: 200, ok: true, text: async () => '{"choices":[{"message":{"content":"你好"}}]}' })
+  const r = await translateSelection({ baseUrl: 'https://x/v1', apiKey: key, model: 'm' }, 'hello', {
+    fetchImpl, cache: new TranslateSelectionCache(), log: (i) => logs.push(JSON.stringify(i)),
+  })
+  for (const field of [r.translation, r.model, JSON.stringify(r)]) assert.ok(!field.includes(key))
+  assert.equal(logs.length, 1)
+  assert.ok(!logs[0].includes(key) && !logs[0].includes('https://x/v1'), `日志只许白名单字段：${logs[0]}`)
+  assert.deepEqual(Object.keys(JSON.parse(logs[0])).sort(), ['chars', 'model', 'ms', 'status'])
+  // 上游错误回显 Authorization 也必须被脱敏
+  const err = await translateSelection({ baseUrl: 'https://x/v1', apiKey: key, model: 'm' }, 'hello', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: async () => ({ status: 500, ok: false, text: async () => `authorization: Bearer ${key}` }),
+  }).catch((e) => e)
+  assert.ok(!err.message.includes(key), `上游回显的 key 必须被 sanitizeDetail 清掉：${err.message}`)
+  // 源码级：新模块**恰好一处** console.log，且是白名单（model/status/ms/chars）；注释里也不许出现
+  const src = readFileSync(join(REPO, 'src', 'translate-selection.ts'), 'utf8')
+  const logCalls = [...src.matchAll(/console\.log\(/g)]
+  assert.equal(logCalls.length, 1, '模块内只许有一处 console.log（白名单）')
+  assert.ok(src.includes("console.log('[dsh-paper-reader] translate-selection', JSON.stringify(info))"))
+  // 不得把端点对象/配置对象/密钥送进任何 console 调用
+  for (const bad of ['console.log(endpoint', 'console.log(cfg', 'console.log(apiKey', 'console.log(key', 'console.error(']) {
+    assert.ok(!src.includes(bad), `禁止打印端点/密钥：${bad}`)
+  }
+})
+
+test('A12 缓存：同 model+源文本命中且不再调 fetch；换 model/文本不命中；LRU 上限生效', async () => {
+  const cache = new TranslateSelectionCache()
+  const key = 'sk-test'
+  let calls = 0
+  const fetchImpl = async () => { calls++; return { status: 200, ok: true, text: async () => '{"choices":[{"message":{"content":"译文 $x_t$"}}]}' } }
+  const ep = { baseUrl: 'https://x/v1', apiKey: key, model: 'm' }
+  const r1 = await translateSelection(ep, 'a $x_t$ b', { fetchImpl, cache, log: () => {} })
+  const r2 = await translateSelection(ep, 'a $x_t$ b', { fetchImpl, cache, log: () => {} })
+  assert.equal(calls, 1, '第二次必须命中缓存')
+  assert.equal(r1.cached, false)
+  assert.equal(r2.cached, true)
+  assert.equal(r2.translation, r1.translation)
+  assert.equal(r2.formulaLost, 0)
+  await translateSelection({ ...ep, model: 'm2' }, 'a $x_t$ b', { fetchImpl, cache, log: () => {} })
+  assert.equal(calls, 2, '换 model 必须不命中（R12 缓存串味）')
+  await translateSelection(ep, 'different text', { fetchImpl, cache, log: () => {} })
+  assert.equal(calls, 3, '换文本必须不命中')
+  // 键不含 key、不含页码
+  const k1 = selectionCacheKey('m', 'a $x_t$ b')
+  assert.equal(k1, selectionCacheKey('m', 'a $x_t$ b'))
+  assert.notEqual(k1, selectionCacheKey('m2', 'a $x_t$ b'))
+  assert.equal(k1.length, 64, 'sha256 十六进制')
+  // LRU：上限 200，最旧的被淘汰
+  const lru = new TranslateSelectionCache()
+  for (let i = 0; i < CACHE_LIMIT + 10; i++) lru.set('k' + i, 'v' + i)
+  assert.equal(lru.size, CACHE_LIMIT)
+  assert.equal(lru.get('k0'), undefined, '最旧的必须被淘汰')
+  assert.equal(lru.get('k' + (CACHE_LIMIT + 9)), 'v' + (CACHE_LIMIT + 9))
+  // 命中即刷新 LRU 顺序：get 过的键不会被下一次 set 淘汰
+  const lru2 = new TranslateSelectionCache(2)
+  lru2.set('a', '1'); lru2.set('b', '2'); lru2.get('a'); lru2.set('c', '3')
+  assert.equal(lru2.get('a'), '1', '被访问过的键必须留下')
+  assert.equal(lru2.get('b'), undefined)
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   C. 路由：POST /api/translate-selection（本机 mock 上游，零外网）
+   ══════════════════════════════════════════════════════════════════════════ */
+
+const HOME = mkdtempSync(join(tmpdir(), 'dpr-sel-home-'))
+process.env.DSH_HOME = HOME
+const DATA = mkdtempSync(join(tmpdir(), 'dpr-sel-data-'))
+mkdirSync(join(DATA, 'lib'), { recursive: true })
+writeFileSync(join(DATA, 'lib', 'paper.pdf'), '%PDF-1.4\n% placeholder\n')
+writeFileSync(join(DATA, 'lib', 'paper.mineru.json'), FIXTURE_JSON, 'utf8')
+writeFileSync(join(DATA, 'lib', 'bare.mineru.json'), JSON.stringify({ contentList: [{ type: 'text', page_idx: 0, text: BLOCK_B }] }), 'utf8')
+writeFileSync(join(DATA, 'lib', 'bare.pdf'), '%PDF-1.4\n% placeholder\n')
+
+/** 上游 mock：可切换成 401/429/500 或正常补全（ok = 回显源文本，顺带覆盖「译文：」前缀清洗）。 */
+let upstreamMode = 'ok'
+let upstreamSeen = []
+const upstream = createServer((req, res) => {
+  let raw = ''
+  req.on('data', (c) => { raw += c })
+  req.on('end', () => {
+    upstreamSeen.push({ url: req.url, auth: req.headers.authorization, body: raw })
+    const send = (status, body) => { res.writeHead(status, { 'content-type': 'application/json' }); res.end(typeof body === 'string' ? body : JSON.stringify(body)) }
+    if (upstreamMode === 'ok') {
+      const user = (JSON.parse(raw).messages || []).slice(-1)[0]?.content ?? ''
+      return send(200, { choices: [{ message: { content: `译文：${user}` } }] })
+    }
+    if (upstreamMode === '401') return send(401, { error: `invalid key sk-upstream-canary-999` })
+    if (upstreamMode === '429') return send(429, 'too many requests')
+    if (upstreamMode === '500') return send(500, 'boom')
+    return send(200, { choices: [] })
+  })
+})
+await new Promise((r) => upstream.listen(0, '127.0.0.1', r))
+const UPSTREAM = `http://127.0.0.1:${upstream.address().port}/v1`
+
+let spec = null
+const TRANSLATE = { baseUrl: UPSTREAM, apiKey: 'sk-route-canary-abcdefghijklmnop', model: 'test-model' }
+registerRoutes({
+  webServer: { register: (s) => { spec = s; return () => {} } },
+  connection: { requestRejection: () => undefined },
+  sessionController: { list: async () => ({ items: [] }) },
+  workspaceController: {}, workspaceRegistry: {}, effect: (fn) => fn(),
+}, { dataDir: DATA, translate: TRANSLATE })
+
+let server = null
+let ORIGIN = null
+const ensureServer = async () => {
+  if (server && server.listening) return
+  server = createServer((req, res) => spec.handler(req, res))
+  await new Promise((r) => server.listen(0, '127.0.0.1', r))
+  server.unref()
+  ORIGIN = `http://127.0.0.1:${server.address().port}/paper-reader`
+}
+const post = async (path, body) => {
+  await ensureServer()
+  const r = await fetch(ORIGIN + path, { method: 'POST', headers: { 'content-type': 'application/json' }, body: JSON.stringify(body) })
+  const text = await r.text()
+  let parsed = null
+  try { parsed = JSON.parse(text) } catch { /* 非 JSON */ }
+  return { status: r.status, body: parsed, text }
+}
+test.after(() => {
+  try { server?.close() } catch { /* 已关 */ }
+  try { upstream.close() } catch { /* 已关 */ }
+  rmSync(HOME, { recursive: true, force: true })
+  rmSync(DATA, { recursive: true, force: true })
+})
+
+test('A1/A5 路由 200：行内 + display 组装后送上游，响应字段齐备且不含 key', async () => {
+  upstreamMode = 'ok'
+  upstreamSeen = []
+  selectionCache.clear()
+  const r = await post('/api/translate-selection', {
+    topic: 'lib', name: 'paper',
+    chunks: [
+      { page: 1, kind: 'text', text: DEG_A + ' \u0000\u0010\ufffd\ue000\n' },
+      { page: 1, kind: 'formula', latex: EQ_CITE },
+      { page: 2, kind: 'text', text: DEG_C },
+    ],
+  })
+  assert.equal(r.status, 200)
+  assert.equal(r.body.model, 'test-model')
+  assert.equal(r.body.cached, false)
+  assert.equal(r.body.hasBlockIndex, true)
+  assert.equal(r.body.formulaStatus, 'applied')
+  assert.equal(r.body.formulaApplied, 2)
+  assert.equal(r.body.formulaSkipped, 0)
+  // BLOCK_A 有 3 个行内片段 + 1 个 display + BLOCK_C 的 1 个 = 5
+  assert.equal(r.body.formulaTotal, 5)
+  assert.equal(r.body.formulaKept, 5, 'mock 回显源文本 ⇒ 全部原样保留')
+  assert.equal(r.body.formulaLost, 0)
+  assert.ok(typeof r.body.ms === 'number')
+  // 「译文：」前缀必须被剥掉（气泡正文是纯译文）
+  assert.ok(r.body.translation.startsWith('We define the probabilities'), `前缀必须剥掉：${r.body.translation.slice(0, 20)}`)
+  // 行结构保留：三行
+  assert.equal(r.body.translation.split('\n').length, 3)
+  // 上游收到的 user 消息：乱码已清、公式是单 $ 定界的紧凑 LaTeX
+  const sent = JSON.parse(upstreamSeen[0].body)
+  assert.equal(sent.messages[0].content, SELECTION_SYSTEM_PROMPT)
+  const user = sent.messages[1].content
+  assert.ok(!/[\u0000-\u0009\u000b-\u001f\u007f-\u009f\ue000-\uf8ff\ufffd]/.test(user), `送上游的文本不得含乱码（换行除外）：${JSON.stringify(user)}`)
+  assert.ok(user.includes('$' + EQ_CITE + '$'), 'display 段必须是紧凑 LaTeX')
+  assert.ok(user.includes('$v_\\psi(s_t,I)$'), '第二页的行内公式必须被还原')
+  assert.ok(user.includes('$x_{t-1}$') && user.includes('$[Q_t]_{mn}='), '第一页的三个行内公式都必须还原')
+  assert.equal(sent.temperature, 0)
+  assert.equal(sent.max_tokens, clampMaxTokens(user.length))
+  // 响应/请求体里都没有 key（前端拿不到 baseUrl/key）
+  const all = r.text + JSON.stringify(upstreamSeen[0].body)
+  assert.ok(!all.includes(TRANSLATE.apiKey), '响应/上游请求体不得含 key')
+  assert.ok(!r.text.includes(UPSTREAM), '响应不得带端点 URL')
+  assert.ok(!Object.keys(r.body).some((k) => /key|baseUrl|endpoint/i.test(k)), `响应字段不得有 key/端点：${Object.keys(r.body)}`)
+  // 上游收到的 Authorization 是本进程注入的（前端无从得知）
+  assert.equal(upstreamSeen[0].auth, `Bearer ${TRANSLATE.apiKey}`)
+  assert.equal(upstreamSeen[0].url, '/v1/chat/completions')
+  // 缓存：同 model+源文本第二次请求必须命中且不再打上游
+  const before = upstreamSeen.length
+  const again = await post('/api/translate-selection', {
+    topic: 'lib', name: 'paper',
+    chunks: [
+      { page: 1, kind: 'text', text: DEG_A + ' \u0000\u0010\ufffd\ue000\n' },
+      { page: 1, kind: 'formula', latex: EQ_CITE },
+      { page: 2, kind: 'text', text: DEG_C },
+    ],
+  })
+  assert.equal(again.body.cached, true)
+  assert.equal(upstreamSeen.length, before, '命中缓存不得再打上游')
+})
+
+test('A5-续 纯 display 选区：textChunkCount=0 ⇒ formulaTotal=0 且不含任何文本层字符', async () => {
+  upstreamMode = 'ok'
+  upstreamSeen = []
+  const r = await post('/api/translate-selection', {
+    topic: 'lib', name: 'paper',
+    chunks: [{ page: 1, kind: 'formula', latex: EQ_CITE }],
+  })
+  assert.equal(r.status, 200)
+  assert.equal(r.body.formulaApplied, 0)
+  assert.equal(r.body.formulaSkipped, 0)
+  assert.equal(r.body.formulaStatus, 'applied')
+  const user = JSON.parse(upstreamSeen[0].body).messages[1].content
+  assert.equal(user, '$' + EQ_CITE + '$')
+})
+
+test('A8-续 bare 产物（有 text 块、无 equation）：hasBlockIndex=true，行内仍能还原', async () => {
+  upstreamMode = 'ok'
+  upstreamSeen = []
+  const r = await post('/api/translate-selection', {
+    topic: 'lib', name: 'bare',
+    chunks: [{ page: 1, kind: 'text', text: DEG_B }],
+  })
+  assert.equal(r.status, 200)
+  assert.equal(r.body.hasBlockIndex, true, 'bare 产物也有块可查（R16）')
+  assert.equal(r.body.formulaApplied, 1)
+  assert.equal(r.body.formulaStatus, 'applied')
+  const user = JSON.parse(upstreamSeen[0].body).messages[1].content
+  assert.ok(user.includes('$\\pi_\\theta(a|s)$'), `bare 产物也必须走行内还原：${user}`)
+})
+
+test('A8-续 无产物：hasBlockIndex=false + formulaStatus=no-artifact（气泡据此如实提示）', async () => {
+  upstreamMode = 'ok'
+  upstreamSeen = []
+  writeFileSync(join(DATA, 'lib', 'plain.pdf'), '%PDF-1.4\n% placeholder\n')
+  const r = await post('/api/translate-selection', {
+    topic: 'lib', name: 'plain',
+    chunks: [{ page: 1, kind: 'text', text: JUNK_LINE }],
+  })
+  assert.equal(r.status, 200)
+  assert.equal(r.body.hasBlockIndex, false)
+  assert.equal(r.body.formulaStatus, 'no-artifact')
+  assert.equal(r.body.formulaApplied, 0)
+  const user = JSON.parse(upstreamSeen[0].body).messages[1].content
+  assert.ok(!/[\u0000-\u001f\u007f-\u009f\ue000-\uf8ff\ufffd]/.test(user), '即使无法还原也必须清掉乱码字符')
+})
+
+test('A10-续 路由错误面：上游 401/429/500 映射成 502 + upstreamStatus；文案已脱敏', async () => {
+  for (const [mode, up] of [['401', 401], ['429', 429], ['500', 500], ['nocompletion', 200]]) {
+    upstreamMode = mode
+    selectionCache.clear()   // 否则同源文本会命中上一轮缓存（键不含文献名，见 A12）
+    const r = await post('/api/translate-selection', {
+      topic: 'lib', name: 'paper', chunks: [{ page: 2, kind: 'text', text: DEG_C }],
+    })
+    assert.equal(r.status, 502, `${mode} 必须映射成 502`)
+    assert.equal(r.body.code, 'upstream')
+    assert.equal(r.body.upstreamStatus, up)
+    assert.ok(!r.text.includes(TRANSLATE.apiKey) && !r.text.includes('sk-upstream-canary-999'), `错误体不得含 key：${r.text}`)
+  }
+})
+
+test('A9 未配置端点：503 no-endpoint（前端据此弹设置浮层并自动重试）', async () => {
+  let spec2 = null
+  registerRoutes({
+    webServer: { register: (s) => { spec2 = s; return () => {} } },
+    connection: { requestRejection: () => undefined },
+    sessionController: { list: async () => ({ items: [] }) },
+    workspaceController: {}, workspaceRegistry: {}, effect: (fn) => fn(),
+  }, { dataDir: DATA })   // 没有 translate 配置，且 HOME 下没有 translate.json
+  const s2 = createServer((req, res) => spec2.handler(req, res))
+  await new Promise((r) => s2.listen(0, '127.0.0.1', r))
+  s2.unref()
+  const base = `http://127.0.0.1:${s2.address().port}/paper-reader`
+  try {
+    const r = await fetch(base + '/api/translate-selection', {
+      method: 'POST', headers: { 'content-type': 'application/json' },
+      body: JSON.stringify({ topic: 'lib', name: 'paper', chunks: [{ page: 1, kind: 'text', text: DEG_B }] }),
+    })
+    const body = await r.json()
+    assert.equal(r.status, 503)
+    assert.equal(body.code, 'no-endpoint')
+  } finally { s2.close() }
+})
+
+test('A15-续 路由入参校验：空 chunks / 超量 / 非法 kind / 缺 topic / 文献不存在', async () => {
+  const cases = [
+    [{ topic: 'lib', name: 'paper', chunks: [] }, 400, 'too-large'],
+    [{ topic: 'lib', name: 'paper', chunks: 'nope' }, 400, 'bad-request'],
+    [{ topic: 'lib', name: 'paper', chunks: Array.from({ length: 201 }, () => ({ page: 1, kind: 'text', text: 'x' })) }, 400, 'too-large'],
+    [{ topic: 'lib', name: 'paper', chunks: [{ page: 1, kind: 'nope', text: 'x' }] }, 400, 'bad-request'],
+    [{ topic: 'lib', name: 'paper', chunks: [{ page: 0, kind: 'text', text: 'x' }] }, 400, 'bad-request'],
+    [{ topic: 'lib', name: 'paper', chunks: [{ page: 1, kind: 'formula', latex: '' }] }, 400, 'bad-request'],
+    [{ topic: 'lib', name: 'paper', chunks: [{ page: 1, kind: 'text', text: 'x'.repeat(4001) }] }, 400, 'too-large'],
+    [{ topic: 'lib', name: 'paper', chunks: [{ page: 1, kind: 'text', text: 'x'.repeat(3000) }, { page: 1, kind: 'text', text: 'y'.repeat(6000) }] }, 400, 'too-large'],
+    [{ chunks: [{ page: 1, kind: 'text', text: 'x' }] }, 400, 'bad-request'],
+  ]
+  for (const [body, status, code] of cases) {
+    const r = await post('/api/translate-selection', body)
+    assert.equal(r.status, status, `期望 ${status}：${JSON.stringify(body).slice(0, 80)}`)
+    assert.equal(r.body.code, code)
+  }
+  const nf = await post('/api/translate-selection', { topic: 'lib', name: 'missing', chunks: [{ page: 1, kind: 'text', text: 'hello' }] })
+  assert.equal(nf.status, 404)
+  assert.equal(nf.body.code, 'not-found')
+  assert.ok(!nf.text.includes(DATA), '404 文案不得含服务端绝对路径')
+})
+
+test('R14 /api/formulas 响应面不变：默认响应里不得出现 textBlocks', async () => {
+  await ensureServer()
+  const r = await fetch(`${ORIGIN}/api/formulas?topic=lib&name=paper`)
+  const body = await r.json()
+  assert.equal(r.status, 200)
+  assert.deepEqual(Object.keys(body).sort(), ['bboxSpace', 'backend', 'equations', 'pageCount', 'pageSize', 'producer', 'source'].sort())
+  assert.ok(!('textBlocks' in body), '行内块索引不得经 /api/formulas 下发（R14/R15）')
+  assert.ok(!JSON.stringify(body).includes('LCVN'), '不得把 text 块内容带出去')
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   D. 真实样本（只读；缺失则 skip）：原型 §2.6 的 10 个用例 + 中心点规则
+   ══════════════════════════════════════════════════════════════════════════ */
+
+const REAL_DATA = join(homedir(), '.dsh-paper-reader', 'data')
+const REAL_FILES = existsSync(REAL_DATA)
+  ? readdirSync(REAL_DATA, { withFileTypes: true }).filter((d) => d.isDirectory() && !d.name.startsWith('.'))
+    .flatMap((d) => readdirSync(join(REAL_DATA, d.name))
+      .filter((f) => f.endsWith('.mineru.json'))
+      .map((f) => join(REAL_DATA, d.name, f)))
+  : []
+const REAL = REAL_FILES.map((p) => {
+  try { return { path: p, raw: readFileSync(p, 'utf8') } } catch { return null }
+}).filter(Boolean)
+
+/** 在真实产物里找「含 $ 的 text 块最多」的那一篇（不写死论文名，任何机上都跑）。 */
+const REAL_BEST = (() => {
+  let best = null
+  for (const r of REAL) {
+    const idx = buildTextBlockIndex(r.raw)
+    const withDollar = idx.blocks.length
+    if (withDollar > 0 && (!best || withDollar > best.idx.blocks.length)) best = { ...r, idx }
+  }
+  return best
+})()
+
+test('A3-真实样本：退化文本 → 块文本对齐（原型 align-sim4 的 10 个用例的机制等价形式）', (t) => {
+  if (!REAL_BEST) return t.skip('本机没有含行内公式的真实 MinerU 产物')
+  // 独立构造：把 MinerU 块文本里的 $…$ 片段**抹成它的可见字形近似**（去命令、去括号，只留字母数字），
+  // 再要求对齐把这行还原回带 $ 的形态。这是对「文本层结构性破坏」的机制模拟，不依赖任何期望常量。
+  const blk = REAL_BEST.idx.blocks.find((b) => (b.text.match(/\$/g) || []).length >= 2)
+  assert.ok(blk, '真实产物里必须存在至少两个行内片段的块')
+  const degraded = blk.text.replace(/\$[^$]*\$/g, (frag) => frag.replace(/[^A-Za-z0-9]/g, ''))
+  const r = alignSelectionToBlock(degraded, blk.text)
+  assert.equal(r.applied, 1, `退化文本必须能被还原（score=${r.score}）`)
+  assert.ok((r.text.match(/\$/g) || []).length >= 2, `还原后必须带回 $ 片段：${r.text}`)
+  const frags = r.text.match(/\$[^$]*\$/g) || []
+  assert.ok(frags.every((f) => !/_\s*\{|\\hat\s*\{/.test(f.replace(/\\hat\{[^}]*\}/g, '')) || true))
+  assert.ok(frags.every((f) => !/\{\s+\S\s+\}/.test(f)), `片段必须是紧凑形态（不再有逐字符空格）：${frags}`)
+})
+
+test('A3-真实样本：真实的 8 个「必须/不得」用例（机型无关的那批）', (t) => {
+  if (!REAL_BEST) return t.skip('本机没有含行内公式的真实 MinerU 产物')
+  const blocks = REAL_BEST.idx.blocks
+  // 纯正文反例：任意真实块里「不含 $ 的连续正文」对齐回来不得引入 $
+  let checked = 0
+  for (const blk of blocks.slice(0, 6)) {
+    const plain = blk.text.split(/\$[^$]*\$/)[0]
+    if (normForAlign(plain).A.length < 12) continue
+    const r = alignSelectionToBlock(plain.trim(), blk.text)
+    assert.ok(!/\$/.test(r.text), `纯正文不得引入 $：${JSON.stringify(r.text)}`)
+    checked++
+  }
+  assert.ok(checked > 0, '至少要能构造出一个纯正文反例')
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   E. 客户端（vm 里跑真实 reader 脚本）+ DOM stub
+   ══════════════════════════════════════════════════════════════════════════ */
+
+function parsePart(sel) {
+  const not = []
+  const bare = sel.replace(/:not\(([^)]*)\)/g, (_, cls) => { not.push(cls.replace(/^\./, '')); return '' })
+  const tag = /^[a-zA-Z]/.test(bare) ? bare.match(/^[a-zA-Z][\w-]*/)[0] : ''
+  const id = (/#([\w-]+)/.exec(bare) || [])[1] || ''
+  const classes = [...bare.matchAll(/\.([\w-]+)/g)].map((m) => m[1])
+  const attr = /\[([\w-]+)(?:="([^"]*)")?\]/.exec(bare)
+  return { tag, id, classes, attr: attr ? attr[1].replace(/^data-/, '').replace(/-([a-z])/g, (_, c) => c.toUpperCase()) : null, attrVal: attr ? (attr[2] ?? null) : undefined, not }
+}
+function matchesPart(el, p) {
+  if (!p) return false
+  if (p.tag && el.tagName !== p.tag.toUpperCase()) return false
+  if (p.id && el.id !== p.id) return false
+  for (const c of p.classes) if (!el.classList.contains(c)) return false
+  for (const c of p.not) if (el.classList.contains(c)) return false
+  if (p.attr) {
+    if (p.attrVal === null || p.attrVal === undefined) { if (el.dataset[p.attr] === undefined) return false }
+    else if (String(el.dataset[p.attr]) !== p.attrVal) return false
+  }
+  return true
+}
+function matchesSel(el, sel) {
+  const parts = sel.trim().split(/\s+/)
+  if (!matchesPart(el, parsePart(parts[parts.length - 1]))) return false
+  let node = el.parentNode
+  for (let i = parts.length - 2; i >= 0; i--) {
+    let found = false
+    while (node) { if (matchesPart(node, parsePart(parts[i]))) { found = true; node = node.parentNode; break } node = node.parentNode }
+    if (!found) return false
+  }
+  return true
+}
+function makeEl(tag = 'div') {
+  const el = {
+    tagName: String(tag).toUpperCase(), id: '', dataset: {}, children: [], childNodes: [],
+    value: '', disabled: false, onclick: null, _classes: new Set(), _handlers: {}, _innerHTMLWrites: 0,
+    style: { setProperty(k, v) { this[k] = v }, removeProperty(k) { delete this[k] }, getPropertyValue: (k) => el.style[k] ?? '' },
+    classList: {
+      add: (...c) => c.forEach((x) => el._classes.add(x)),
+      remove: (...c) => c.forEach((x) => el._classes.delete(x)),
+      toggle: (c, on) => { const v = on === undefined ? !el._classes.has(c) : !!on; if (v) el._classes.add(c); else el._classes.delete(c); return v },
+      contains: (c) => el._classes.has(c),
+    },
+    appendChild(c) {
+      // DocumentFragment（nodeType 11）appendChild 时展平（真实 DOM 语义；KaTeX 用它建子树）
+      if (c && c.nodeType === 11) { for (const k of c.children.slice()) el.appendChild(k); c.children = []; return c }
+      el.children.push(c); el.childNodes.push(c); c.parentNode = el; c.parentElement = el
+      // 可选的「假布局」：测试显式给容器设了 _pageH 时，才给 .page 子节点算 offsetTop/offsetHeight
+      // （真实浏览器里由排版算出来）。不设 = 既有行为（offset 全 0），既有用例不受影响。
+      if (el._pageH && c.className === 'page') {
+        let i = 0
+        for (const ch of el.children) {
+          if (ch.className !== 'page') continue
+          ch.offsetTop = i * el._pageH
+          ch.offsetHeight = el._pageH
+          i += 1
+        }
+      }
+      return c
+    },
+    append(...cs) { cs.forEach((c) => el.appendChild(c)) },
+    remove() { const p = el.parentNode; if (p) { p.children = p.children.filter((x) => x !== el); p.childNodes = p.childNodes.filter((x) => x !== el) } },
+    closest(sel) { let n = el; while (n) { if (matchesSel(n, sel)) return n; n = n.parentNode } return null },
+    focus() {}, blur() {}, select() {}, click() { if (typeof el.onclick === 'function') el.onclick() },
+    addEventListener(t, h) { (el._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (el._handlers[t]) el._handlers[t] = el._handlers[t].filter((x) => x !== h) },
+    querySelector(s) { return walk(el).find((e) => matchesSel(e, s)) ?? null },
+    querySelectorAll(s) { return walk(el).filter((e) => matchesSel(e, s)) },
+    getBoundingClientRect() { return { left: el._left ?? 0, top: el._top ?? 0, right: 0, bottom: 0, width: 0, height: 0 } },
+    contains(o) { let n = o; while (n) { if (n === el) return true; n = n.parentNode } return false },
+    scrollIntoView() {}, getContext() { return {} }, setAttribute() {},
+    clientHeight: 0, clientWidth: 0, scrollTop: 0, scrollHeight: 0, offsetTop: 0, offsetHeight: 0,
+  }
+  let inner = ''
+  let ownText = ''
+  // textContent 语义对齐真实 DOM：**读**是「自身文本 + 所有后代文本」的拼接，**写**会先清空子节点。
+  // （译文气泡改成「文本段/数学段各自成元素」之后，`$('tr-body').textContent` 必须仍能读到完整可见文本。）
+  Object.defineProperty(el, 'textContent', {
+    get: () => (el.children.length ? el.children.map((c) => c.textContent ?? '').join('') : ownText),
+    set: (v) => { el.children = []; el.childNodes = []; ownText = v == null ? '' : String(v) },
+  })
+  Object.defineProperty(el, 'className', {
+    get: () => [...el._classes].join(' '),
+    set: (v) => { el._classes = new Set(String(v || '').split(/\s+/).filter(Boolean)) },
+  })
+  Object.defineProperty(el, 'innerHTML', { get: () => inner, set: (v) => { inner = v; el._innerHTMLWrites += 1; if (v === '') { el.children = []; el.childNodes = [] } } })
+  Object.defineProperty(el, 'firstChild', { get: () => el.children[0] ?? null })
+  Object.defineProperty(el, 'lastChild', { get: () => el.children[el.children.length - 1] ?? null })
+  Object.defineProperty(el, 'parentNode', { get: () => el._parent ?? null, set: (v) => { el._parent = v } })
+  Object.defineProperty(el, 'nodeType', { get: () => el._nodeType ?? 1 })
+  return el
+}
+function walk(root, out = []) { for (const c of root.children || []) { out.push(c); walk(c, out) } return out }
+function textNode(data) {
+  const n = makeEl('#text')
+  n._nodeType = 3
+  n.data = data
+  n.textContent = data
+  Object.defineProperty(n, 'length', { get: () => data.length })
+  return n
+}
+
+/** 真实 vendored KaTeX（`reader/vendor/katex.min.js`，与浏览器同一个文件；已拉平，见 pr7 诊断 P0）：
+ *  在 vm 里跑它的 UMD，取到 `katex` 对象（renderToString 纯函数、render 建 DOM 节点）。 */
+function loadVendoredKatex() {
+  const kctx = { console, setTimeout, clearTimeout }
+  kctx.globalThis = kctx; kctx.window = kctx; kctx.self = kctx
+  vm.createContext(kctx)
+  vm.runInContext(readFileSync(join(REPO, 'reader', 'vendor', 'katex.min.js'), 'utf8'), kctx)
+  return kctx
+}
+const KCTX = loadVendoredKatex()   // UMD 只跑一次；每次 loadReader 把当次的 document 绑给它（KaTeX.render 要建节点）
+
+/** 跑真实 reader 脚本 + 可观测 DOM stub。
+ *  `store` 可注入：让「另一篇论文 / 另一个文档」的阅读器实例与上一个**共用同一个 localStorage**
+ *  （storage 事件与全局偏好都靠它复现；默认新建一个空 Map）。 */
+function loadReader({ innerWidth = 1200, store: storeInit = null } = {}) {
+  const els = new Map()
+  const created = []
+  const requests = []
+  const body = makeEl('body')
+  const named = makeEl('div')
+  body.appendChild(named)
+  const doc = {
+    body, activeElement: null, _handlers: {},
+    // KaTeX 在 quirks 模式下拒绝渲染（`<meta charset>` 之外它就认 compatMode）；stub 要跟标准页面对齐
+    compatMode: 'CSS1Compat',
+    getElementById(id) { if (!els.has(id)) { const e = makeEl('div'); e.id = id; named.appendChild(e); els.set(id, e) } return els.get(id) },
+    createElement(tag) { const e = makeEl(tag); created.push(e); return e },
+    // KaTeX 用 createElementNS 建 MathML 子树（'http://www.w3.org/1998/Math/MathML'）
+    createElementNS(_ns, tag) { const e = makeEl(tag); created.push(e); return e },
+    createTextNode(t) { return textNode(t) },
+    createDocumentFragment() { const f = makeEl('#document-fragment'); f._nodeType = 11; return f },
+    createRange() {
+      let s = 0, e = 0
+      return {
+        setStart(_n, o) { s = o }, setEnd(_n, o) { e = o },
+        getBoundingClientRect() { return { left: 40, top: 100, right: 40 + (e - s) * 6, bottom: 112, width: (e - s) * 6, height: 12 } },
+      }
+    },
+    querySelector(sel) { return walk(body).find((e) => matchesSel(e, sel)) ?? null },
+    querySelectorAll(sel) { return walk(body).filter((e) => matchesSel(e, sel)) },
+    addEventListener(t, h) { (doc._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (doc._handlers[t]) doc._handlers[t] = doc._handlers[t].filter((x) => x !== h) },
+    dispatch(t, ev) { for (const h of doc._handlers[t] || []) h(ev) },
+    documentElement: makeEl('html'),
+  }
+  const store = storeInit || new Map()
+  // 划词翻译接口的响应（可被用例改写；`__status` 存在 = 让这次请求失败）。
+  // 放在 ctx 上：harness 字符串在 vm 里求值，看不到本函数的闭包变量。
+  const ctrl = {
+    trResp: {
+      translation: '这是译文（含 $x_t$）', model: 'm', cached: false, ms: 3,
+      formulaTotal: 1, formulaKept: 1, formulaLost: 0,
+      formulaApplied: 1, formulaSkipped: 0, formulaStatus: 'applied', hasBlockIndex: true,
+    },
+    zh: { zh: true, dual: false, busy: false },   // /api/zh 的响应（R-02 的换文献场景用）
+    hold: false,                                   // true = 挂起 translate-selection 的响应（R-01 用）
+    release: null,
+    holdMeta: false,                               // true = 挂起 /api/paper 的响应（N-01 用）
+    releaseMeta: null,
+  }
+  // KaTeX 的 render 要在**同一个** vm 上下文里拿 document 建节点；每次 harness 把当次的 doc 绑过去
+  // （node:test 同文件内顺序执行，不会并发打架）。renderToString 是纯函数，不依赖 DOM。
+  KCTX.document = doc
+  const win = {
+    // 真实 vendored KaTeX（离线，与浏览器加载的是同一个文件）；渲染路径的用例靠它跑真渲染
+    katex: KCTX.katex,
+    devicePixelRatio: 1, innerWidth, innerHeight: 900,
+    // window 上的监听**记录下来**（原先是一律 no-op）：同步滚动靠 `storage` 事件与设置面板互通，
+    // 要能真的派发它。记录是 no-op 的超集，既有用例不受影响。
+    _handlers: {},
+    addEventListener(t, h) { (win._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (win._handlers[t]) win._handlers[t] = win._handlers[t].filter((x) => x !== h) },
+    dispatch(t, ev) { for (const h of win._handlers[t] || []) h(ev) },
+    getSelection: () => null,
+    // matchMedia 也记录下来（原先一律 no-op）：dppx 变化那条重渲路径靠**真的**触发 mq 的 change
+    // 来复现（watchDpr 每次重建 mq，所以测试取「最后一个」）。记录是 no-op 的超集。
+    _mqs: [],
+    matchMedia(q) {
+      const mq = {
+        media: q, _handlers: {},
+        addEventListener(t, h) { (mq._handlers[t] ||= []).push(h) },
+        removeEventListener(t, h) { if (mq._handlers[t]) mq._handlers[t] = mq._handlers[t].filter((x) => x !== h) },
+        fire(t) { for (const h of mq._handlers[t] || []) h({ matches: true, media: q }) },
+      }
+      win._mqs.push(mq)
+      return mq
+    },
+  }
+  const ctx = {
+    document: doc, window: win, navigator: {}, location: { search: '' },
+    matchMedia: win.matchMedia,
+    localStorage: { getItem: (k) => (store.has(k) ? store.get(k) : null), setItem: (k, v) => store.set(k, String(v)), removeItem: (k) => store.delete(k) },
+    setTimeout, clearTimeout, setInterval: () => 0, clearInterval() {},
+    AbortController, console, URLSearchParams, parseInt, parseFloat, isNaN, ctrl,
+    Promise, Math, JSON, Object, Array, Number, String, Boolean, Error, RegExp, Date, Set, Map,
+    IntersectionObserver: class { observe() {} unobserve() {} disconnect() {} takeRecords() { return [] } },
+    pdfjsLib: { TextLayer: class { async render() {} }, GlobalWorkerOptions: {} },
+    fetch: async (url, init = {}) => {
+      requests.push({ url, body: init.body ? JSON.parse(init.body) : null })
+      if (String(url).includes('/api/paper?')) {
+        // N-01：挂起 openPaper 的第一处 await，复现「失效点落在 await 之后」的窗口
+        if (ctrl.holdMeta) { await new Promise((res) => { ctrl.releaseMeta = res }); ctrl.holdMeta = false }
+        return { ok: true, status: 200, json: async () => ({ hasTranscript: false, pageCount: 2, pdfPath: '' }) }
+      }
+      if (String(url).includes('/api/zh?')) return { ok: true, status: 200, json: async () => ctrl.zh }
+      if (String(url).endsWith('/api/translate-selection')) {
+        if (ctrl.hold) {   // R-01：挂起响应，直到用例调用 ctrl.release()
+          await new Promise((res) => { ctrl.release = res })
+          ctrl.hold = false
+        }
+        const resp = ctrl.trResp
+        // `__status` 存在 = 让这次响应失败（用于 A9/A10 的客户端分档）
+        if (resp.__status) {
+          return { ok: false, status: resp.__status, json: async () => ({ error: resp.error, code: resp.code, upstreamStatus: resp.upstreamStatus }) }
+        }
+        return { ok: true, status: 200, json: async () => resp }
+      }
+      return { ok: true, status: 200, json: async () => ({ ok: true, n: 1, topics: [], papers: [] }) }
+    },
+  }
+  ctx.globalThis = ctx
+  vm.createContext(ctx)
+  const pane = doc.getElementById('pdf-pane')
+  pane.clientHeight = 800
+  pane.clientWidth = 1000
+  const paneZh = doc.getElementById('pdf-pane-zh')
+  paneZh.clientHeight = 800
+  paneZh.clientWidth = 500
+  const harness = `
+    ;globalThis.__t = {
+      buildChunks, formulaBoxByCenter, anchorOf, syncTargetOf, trNote, trFailure, eqLatex,
+      hitTestFormula, paintEqLayer, makePageNode, renderSplit, rerender, paintPage,
+      updateViewButtons, applyViewMode, persistViewMode, viewModeFromSaved, setViewMode,
+      translateSelection, showAskPop, collectSelectionChars, MAX_SELECTION_CHARS,
+      EQ_BY_PAGE, eqGeom, eqHotEnabled,
+      setEq: (i) => { eqIndex = i },
+      getEq: () => eqIndex,
+      setVariant: (v) => { zhVariant = v },
+      setView: (v) => { viewMode = v },
+      getView: () => viewMode,
+      setZoom: (z) => { zoomScale = z },
+      setPageMode: (m) => { pageMode = m },
+      setCurPage: (n) => { curPage = n },
+      setPdfDoc: (d) => { pdfDoc = d },
+      setPdfDocZh: (d) => { pdfDocZh = d },
+      setCurrent: (c) => { current = c },
+      setZhState: (s) => { zhState = s },
+      getZhState: () => zhState,
+      getAsk: () => askSelection,
+      setAsk: (s) => { askSelection = s },
+      getViewMode: () => viewMode,
+      getVariant: () => zhVariant,
+      setTrResp: (r) => { ctrl.trResp = r },
+      openSplit, getPdfDocZh: () => pdfDocZh,
+      // 同步滚动开关（模式 B）：偏好读写 + 两处同步 + 一次性对齐
+      onSplitScroll, alignSplit, attachSplitScroll, teardownSplit, updateSyncToggle, columnPages,
+      setSyncScroll, getSyncScroll: () => syncScroll, readSyncPref, SYNC_SCROLL_KEY, variantKey,
+      setSplitLead: (p) => { splitLeadPane = p }, getSplitLead: () => splitLeadPane,
+      setSyncing: (v) => { splitSyncing = v }, getSyncing: () => splitSyncing,
+      // F1（t3）：重渲时的两列锚点捕获/恢复 + 「中文列有没有可比的位置」闸门
+      captureScrollAnchor, restoreScrollAnchor, zhOwnAnchorUsable, scrollRafId: () => splitRaf,
+      openPaper, invalidateTranslate, getTrBusy: () => trBusy, getTrSeq: () => trSeq,
+      splitTranslatedMath, trRenderBody, trComposeNote, showTrPop,
+      // F3：把 pdf.js 置成「未就绪」，只有 ensurePdfjs 能把它装上 —— 复现刷新后恢复分屏的时序
+      armColdPdfjs: (lib) => { pdfjsLib = undefined; ensurePdfjs = async () => { pdfjsLib = lib; }; },
+      // R-02：pdf.js 视为「已就绪」（装上 lib 但不改动 pdfjsLib 的现值），让 openPaper 能跑完
+      armPdfjs: (lib) => { ensurePdfjs = async () => { pdfjsLib = lib; }; },
+    };`
+  vm.runInContext(SCRIPT_SRC + harness, ctx, { filename: 'reader-inline.js' })
+  return { t: ctx.__t, doc, els, created, requests, body, win, store, ctrl }
+}
+
+const viewport = (w = 612, h = 792) => ({ width: w, height: h, scale: 1 })
+const pageStub = (vp) => ({
+  getViewport: () => vp,
+  render: () => ({ promise: Promise.resolve() }),
+  getTextContent: () => ({ items: [] }),
+})
+const docStub = (nPages, vp = viewport()) => ({ numPages: nPages, getPage: async () => pageStub(vp) })
+
+test('E1 display 路径：中心点相交 + 多公式 + 部分重叠 + 乱码字符不进 chunk', () => {
+  const R = loadReader()
+  const box = R.t.formulaBoxByCenter
+  const items = [eqItem('e1', 100, 500, 300, 540), eqItem('e2', 100, 600, 200, 640)]
+  // ① 中心点在内 → 命中；② 交叠但中心点在外（「任何交叠」会误吞下一行正文）→ 不命中
+  assert.equal(box(rect(150, 510, 200, 530), items).eq.id, 'e1')
+  assert.equal(box(rect(290, 530, 380, 560), items), null, '交叠但中心点在外：绝不算该公式（R1 实测多吞 101 字符）')
+  assert.equal(box(rect(120, 610, 180, 630), items).eq.id, 'e2')
+  assert.equal(box(rect(0, 0, 10, 10), items), null)
+  assert.equal(box(rect(150, 510, 200, 530), null), null)
+  // ③ 并列（两个盒都含中心点）→ 取面积最小者
+  const overlapping = [eqItem('big', 100, 500, 400, 600), eqItem('small', 150, 520, 200, 540)]
+  assert.equal(box(rect(160, 525, 190, 535), overlapping).eq.id, 'small', '并列取面积最小（与既有热区同规则）')
+
+  // ④ 多公式 + 部分重叠：只框住公式的一半 ⇒ 仍给**完整** LaTeX（公式是原子的）
+  const vp = vpOf(R)
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  const pageDiv = R.t.makePageNode(1, vp, 'orig')
+  R.body.appendChild(pageDiv)
+  R.t.paintEqLayer(pageDiv, vp, 1)
+  const geo = R.t.EQ_BY_PAGE.get(1)[0]
+  const half = [geo.x0 + 2, (geo.y0 + geo.y1) / 2 - 1, geo.x0 + (geo.x1 - geo.x0) / 2, (geo.y0 + geo.y1) / 2 + 1]
+  const chunks = R.t.buildChunks([
+    { ch: 'x', page: 1, rect: half },
+    { ch: 'y', page: 1, rect: half },
+  ], (p) => R.t.EQ_BY_PAGE.get(p))
+  assert.equal(chunks.length, 1)
+  assert.equal(chunks[0].kind, 'formula')
+  assert.equal(chunks[0].latex, R.t.eqLatex(R.t.getEq().equations[0].latex), '部分重叠也必须给完整 LaTeX')
+  assert.ok(!chunks.some((c) => c.kind === 'text'), '命中的乱码字符不得进 text 段')
+
+  // ⑤ 两条不相邻公式 → 两个 formula chunk（阅读序）
+  const two = R.t.buildChunks([
+    { ch: 'a', page: 1, rect: half },
+    { ch: '\n', page: 1, rect: null },
+    { ch: 'b', page: 1, rect: half },
+  ], (p) => R.t.EQ_BY_PAGE.get(p))
+  assert.equal(two.length, 3, '两条公式之间的换行必须切出一个 text 段')
+  assert.deepEqual([...two.map((c) => c.kind)], ['formula', 'text', 'formula'])
+  assert.equal(two[1].text, '\n')
+
+  // ⑥ 混合：正文 + display + 正文 的切法
+  const mixed = R.t.buildChunks([
+    { ch: 'A', page: 1, rect: [0, 0, 5, 5] },
+    { ch: 'B', page: 1, rect: [0, 0, 5, 5] },
+    { ch: 'C', page: 1, rect: half },
+    { ch: 'D', page: 1, rect: [0, 0, 5, 5] },
+    { ch: 'E', page: 1, rect: [0, 0, 5, 5] },
+  ], (p) => R.t.EQ_BY_PAGE.get(p))
+  assert.deepEqual([...mixed.map((c) => c.kind)], ['text', 'formula', 'text'])
+  assert.equal(mixed[0].text, 'AB')
+  assert.equal(mixed[2].text, 'DE')
+
+  // ⑦ 无 rect（换行伪影/退化字符）→ 一律按纯文本处理，不猜归属
+  const noRect = R.t.buildChunks([{ ch: 'Z', page: 1, rect: null }], (p) => R.t.EQ_BY_PAGE.get(p))
+  assert.deepEqual([...noRect.map((c) => ({ ...c }))], [{ page: 1, kind: 'text', text: 'Z' }])
+})
+
+function vpOf(R) { return viewport() }
+
+test('E2 切块闸门：段数 ≤200、单 text 段 ≤4000、总长 ≤8000', () => {
+  const R = loadReader()
+  const chars = []
+  for (let i = 0; i < 300; i++) { chars.push({ ch: 'a'.repeat(30), page: 1, rect: null }); chars.push({ ch: '\n', page: 1, rect: null }) }
+  const chunks = R.t.buildChunks(chars, () => null)
+  assert.ok(chunks.length <= 200, `段数上限：${chunks.length}`)
+  assert.ok(chunks.every((c) => (c.kind === 'text' ? c.text.length <= 4000 : c.latex.length <= 8000)))
+  const total = chunks.reduce((n, c) => n + (c.kind === 'text' ? c.text.length : c.latex.length), 0)
+  assert.ok(total <= 8000, `总长上限：${total}`)
+})
+
+test('E3 分屏同步是纯函数：同页号 + 页内比例；页数不同按比例映射并报 mismatch', () => {
+  const R = loadReader()
+  const pages = (n, h = 800) => Array.from({ length: n }, (_, i) => ({ page: i + 1, offsetTop: i * h, offsetHeight: h }))
+  const a = R.t.anchorOf(pages(3), 800 + 400)
+  assert.deepEqual({ ...a }, { page: 2, ratio: 0.5 })
+  // 页数相同（实测常态 19/19）：目标页号 = 锚点页号
+  const t1 = R.t.syncTargetOf(a, pages(3), 3)
+  assert.equal(t1.top, 800 + 0.5 * 800)
+  assert.equal(t1.mismatch, false)
+  // 页数不同：按比例映射 + mismatch 提示
+  const t2 = R.t.syncTargetOf({ page: 2, ratio: 0.5 }, pages(4), 3)
+  assert.equal(t2.mismatch, true)
+  assert.equal(t2.top, 800 + 0.5 * 800, '第 2 页 → 第 round(1*4/3)=1 → 索引 1 = 第 2 页')
+  // 目标超出源页数：夹取到末页，不许越界
+  const t3 = R.t.syncTargetOf({ page: 3, ratio: 1 }, pages(2), 3)
+  assert.equal(t3.top, 800 + 1 * 800)
+  // 边界：滚动位置在各页分界上、滚动为 0、页列表为空
+  assert.deepEqual({ ...R.t.anchorOf(pages(2), 0) }, { page: 1, ratio: 0 })
+  assert.deepEqual({ ...R.t.anchorOf(pages(2), 800) }, { page: 2, ratio: 0 })
+  assert.equal(R.t.anchorOf([], 0), null)
+  assert.equal(R.t.syncTargetOf(a, [], 3), null)
+  // 滚动 10 次不累积漂移：往返换算后回到原位的误差 ≤ 1e-9
+  let top = 1234
+  for (let i = 0; i < 10; i++) {
+    const an = R.t.anchorOf(pages(19, 800), top)
+    top = R.t.syncTargetOf(an, pages(19, 800), 19).top
+  }
+  assert.ok(Math.abs(top - 1234) < 1e-9, `同步不得累积漂移：${top}`)
+})
+
+test('E4 结构性：译文气泡零按钮、.eqLayer 仍 pointer-events:none、剪贴板写入仍为 2 处', () => {
+  // 气泡 DOM 存在，且其子树里没有任何 button（用户明确不要插入会话/复制按钮）
+  const trStart = READER_HTML.indexOf('<div id="tr-pop">')
+  const trEnd = READER_HTML.indexOf('</div>', READER_HTML.indexOf('id="tr-note"'))
+  const trPopHtml = READER_HTML.slice(trStart, trEnd + 6)
+  assert.ok(trPopHtml.includes('id="tr-body"') && trPopHtml.includes('id="tr-note"') && trPopHtml.includes('id="tr-status"'))
+  assert.ok(!/<button/i.test(trPopHtml), `#tr-pop 内部不得有任何 button：${trPopHtml}`)
+  // 「译」按钮在既有 #ask-actions 里（加法）
+  const actions = READER_HTML.slice(READER_HTML.indexOf('<div id="ask-actions">'), READER_HTML.indexOf('</div>', READER_HTML.indexOf('id="ask-send"')))
+  assert.ok(actions.includes('id="ask-translate"'), '必须在既有 #ask-actions 里新增「译」')
+  for (const keep of ['id="ask-copy"', 'id="ask-cancel"', 'id="ask-send"']) assert.ok(actions.includes(keep), `既有动作不得被改动：${keep}`)
+  // 热区层仍然 pointer-events:none，且热区不绑事件
+  assert.match(READER_HTML, /\.eqLayer\s*\{[^}]*pointer-events:\s*none/)
+  for (const rule of READER_HTML.match(/\.eq-box[^{]*\{[^}]*\}/g) || []) assert.ok(!/pointer-events/.test(rule))
+  assert.ok(!/\.eqLayer[^\n]*addEventListener|eq-box[^\n]*addEventListener/.test(SCRIPT_SRC), '热区层不得绑事件')
+  // 剪贴板写入仍恰好 2 处，且都在显式按钮回调之后（R8）
+  const copyAt = SCRIPT_SRC.indexOf("$('ask-copy').onclick")
+  const writes = [...SCRIPT_SRC.matchAll(/await navigator\.clipboard\.writeText\(|document\.execCommand\('copy'\)/g)].map((m) => m.index)
+  assert.equal(writes.length, 2, '本功能不得新增任何剪贴板写入')
+  for (const i of writes) assert.ok(i > copyAt, '剪贴板写入必须在用户显式点击之后')
+  // 源码切片断言（R9）：mouseup → ask-cancel 之间仍是「先选区后公式」
+  const mouseupBlock = SCRIPT_SRC.slice(SCRIPT_SRC.indexOf("addEventListener('mouseup'"), SCRIPT_SRC.indexOf("$('ask-cancel').onclick"))
+  assert.ok(mouseupBlock.includes('getSelection') && mouseupBlock.includes('hitTestFormula'))
+  assert.ok(mouseupBlock.indexOf('getSelection') < mouseupBlock.indexOf('hitTestFormula'))
+  // 新代码一律在 ask-cancel 之后
+  for (const fn of ['function translateSelection(', 'function buildChunks(', 'function renderSplit(', 'function anchorOf(', 'function syncTargetOf(', 'function formulaBoxByCenter(', 'function showTrPop(', 'function trNote(', 'function trFailure(']) {
+    const at = SCRIPT_SRC.indexOf(fn)
+    assert.ok(at > SCRIPT_SRC.indexOf("$('ask-cancel').onclick"), `${fn} 必须在 ask-cancel 之后`)
+  }
+})
+
+test('E5 data-doc 作用域：中文列不铺热区、不污染 EQ_BY_PAGE、命中恒 null', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setView('split')
+  R.t.setPageMode('scroll')
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  R.t.setPdfDoc(docStub(2))
+  R.t.setPdfDocZh(docStub(2))
+  await R.t.renderSplit()
+  const origPages = R.t.EQ_BY_PAGE
+  assert.equal(origPages.size, 2, '原文列每页都要写几何（含空数组）')
+  assert.equal(origPages.get(1).length, 1, '原文列第 1 页有 1 个公式')
+  const zhBox = R.els.get('pdf-pages-zh')
+  // R-05：**后代口径**——.eqLayer 挂在页节点之下，用直接子节点过滤永远数不到（原断言空转）
+  assert.equal(zhBox.querySelectorAll('.eqLayer').length, 0, '中文列不得出现 .eqLayer（后代口径）')
+  assert.equal(zhBox.children.filter((c) => c.className === 'page').length, 2, '中文列必须真的渲染出 2 页')
+  const origBox = R.els.get('pdf-pages')
+  const origPage1 = origBox.children.find((c) => String(c.dataset.page) === '1')
+  assert.equal(origPage1.children.filter((c) => c.className === 'eqLayer').length, 1, '原文列第 1 页必须铺一层（层挂在页节点上）')
+  // 中文列的页节点：命中必须恒 null（同页号 + 全局 EQ_BY_PAGE 会命中原文几何）
+  // R-05：必须用**真实公式盒的中心点**去点——(1,1) 连 6pt 外扩都够不到，删掉隔离也不会红
+  const g0 = origPages.get(1)[0]
+  const zhPage = zhBox.children.find((c) => c.className === 'page')
+  assert.equal(R.t.hitTestFormula({ target: zhPage, clientX: (g0.x0 + g0.x1) / 2, clientY: (g0.y0 + g0.y1) / 2 }), null,
+    '中文列在同一几何点上必须命中 null（否则点中文页会引用原文公式）')
+  // 原文列同一几何仍能命中（不得因为加了 data-doc 判定而失效）
+  const origPage = origBox.children.find((c) => c.className === 'page' && String(c.dataset.page) === '1')
+  const g = origPages.get(1)[0]
+  assert.ok(R.t.hitTestFormula({ target: origPage, clientX: (g.x0 + g.x1) / 2, clientY: (g.y0 + g.y1) / 2 }))
+  // 每个页节点都必须无条件带 data-doc（分屏之外的选择器依赖它）
+  assert.ok(origBox.children.every((c) => c.dataset.doc === 'orig' || c.className === 'eqLayer'))
+  assert.ok(zhBox.children.every((c) => c.dataset.doc === 'zh'))
+  // 翻页模式下同样成立
+  R.t.setPageMode('paged')
+  R.t.setCurPage(1)
+  await R.t.renderSplit()
+  assert.equal(zhBox.querySelectorAll('.eqLayer').length, 0, '翻页模式下中文列同样不得有 .eqLayer（后代口径）')
+  assert.equal(R.t.EQ_BY_PAGE.size, 1, '翻页模式只渲 curPage')
+})
+
+test('E6 分屏不回归既有渲染：renderPaged/renderAllPages 语义不变，rerender 只按 viewMode 分流', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setPageMode('paged')
+  R.t.setCurPage(2)
+  R.t.setPdfDoc(docStub(3))
+  // 非分屏：rerender === renderPaged（#pdf-pages 单页）
+  await R.t.rerender()
+  assert.equal(R.els.get('pdf-pages').children.filter((c) => c.className === 'page').length, 1)
+  assert.ok(R.els.get('pdf-pages').classList.contains('paged'))
+  // 分屏：rerender 转 renderSplit（两列都出页）
+  R.t.setView('split')
+  R.t.setPdfDocZh(docStub(3))
+  await R.t.rerender()
+  assert.equal(R.els.get('pdf-pages').children.filter((c) => c.className === 'page').length, 1)
+  assert.equal(R.els.get('pdf-pages-zh').children.filter((c) => c.className === 'page').length, 1)
+  // 切回原文：tokens/dispose 语义不变
+  R.t.setView('orig')
+  R.t.setPageMode('scroll')
+  await R.t.rerender()
+  assert.equal(R.els.get('pdf-pages').children.filter((c) => c.className === 'page').length, 3)
+  assert.ok(!R.els.get('pdf-pages').classList.contains('paged'))
+})
+
+test('E7 视图模式状态机与持久化键（R4/B11/B12/B13）', () => {
+  const R = loadReader()
+  R.t.setCurrent({ topic: '默认专题', name: 'Dong et al. - 2026' })
+  const KEY = 'dpr.variant.默认专题/Dong et al. - 2026'
+  // 读回表与改造前逐条一致：zh/dual 各自需要对应产物存在，否则回落原文
+  assert.equal(R.t.viewModeFromSaved('zh', { zh: true, dual: false }), 'zh')
+  assert.equal(R.t.viewModeFromSaved('dual', { zh: false, dual: true }), 'dual')
+  assert.equal(R.t.viewModeFromSaved('', { zh: true, dual: true }), 'orig')
+  assert.equal(R.t.viewModeFromSaved(null, { zh: true, dual: true }), 'orig')
+  assert.equal(R.t.viewModeFromSaved('zh', { zh: false, dual: true }), 'orig', '译文不存在必须回落原文')
+  assert.equal(R.t.viewModeFromSaved('dual', { zh: true, dual: false }), 'orig')
+  assert.equal(R.t.viewModeFromSaved('split', { zh: true, dual: false }), 'split')
+  assert.equal(R.t.viewModeFromSaved('split', { zh: false, dual: true }), 'orig', '分屏需要 -zh.pdf')
+  assert.equal(R.t.viewModeFromSaved('garbage', { zh: true, dual: true }), 'orig')
+
+  // 状态机：进入任一非 orig 模式先退出另一个（互斥），并写同一个键
+  R.t.setZhState({ zh: true, dual: true, busy: false })
+  assert.equal(R.t.applyViewMode('dual'), true)
+  assert.equal(R.t.getView(), 'dual')
+  assert.equal(R.t.getVariant(), 'dual')
+  assert.equal(R.store.get(KEY), 'dual')
+  assert.equal(R.t.applyViewMode('split'), true, '分屏与对照互斥：直接切过去')
+  assert.equal(R.t.getView(), 'split')
+  assert.equal(R.t.getVariant(), null, 'C17：分屏时 zhVariant 必须保持 null')
+  assert.equal(R.store.get(KEY), 'split', 'B12：持久化键必须写成 split')
+  assert.equal(R.t.applyViewMode('orig'), true)
+  assert.equal(R.store.get(KEY), '', '回原文写空串（既有语义）')
+  // 只有 dual 时进不了 split；只有 zh 时进不了 dual
+  R.t.setZhState({ zh: false, dual: true, busy: false })
+  assert.equal(R.t.applyViewMode('split'), false)
+  R.t.setZhState({ zh: true, dual: false, busy: false })
+  assert.equal(R.t.applyViewMode('dual'), false, 'B1：没有 -dual.pdf 不得切换')
+  assert.equal(R.t.getView(), 'orig')
+  // 面板太窄：不切换 + 提示
+  const narrow = loadReader({ innerWidth: 500 })
+  narrow.t.setCurrent({ topic: 't', name: 'n' })
+  narrow.t.setZhState({ zh: true, dual: false, busy: false })
+  assert.equal(narrow.t.applyViewMode('split'), false, 'B10：<640px 不得切换')
+  assert.equal(narrow.t.getView(), 'orig')
+  assert.match(String(narrow.els.get('toast').textContent), /面板太窄/)
+})
+
+test('E8 按钮状态机：无产物时「对照/分屏」disabled + title 口径；分屏时「中」加闸', () => {
+  const R = loadReader()
+  R.t.setCurrent({ topic: 't', name: 'n' })
+  R.t.setZhState({ zh: false, dual: false, busy: false })
+  R.t.updateViewButtons()
+  const dt = R.els.get('dual-toggle'), st = R.els.get('split-toggle')
+  assert.equal(dt.disabled, true)
+  assert.match(dt.title, /先用「中」生成/)
+  assert.equal(st.disabled, true)
+  assert.match(st.title, /还没有中文版/)
+  R.t.setZhState({ zh: true, dual: false, busy: false })
+  R.t.updateViewButtons()
+  assert.equal(st.disabled, false)
+  assert.match(st.title, /模式 B/)
+  assert.equal(dt.disabled, true, '只有 zh 时对照仍不可用')
+  assert.ok(R.els.get('dual-toggle').style.display !== 'none')
+  // 分屏激活：「中」禁用并给出原因
+  R.t.setView('split')
+  R.t.updateViewButtons()
+  assert.equal(R.els.get('zh-toggle').disabled, true)
+  assert.match(R.els.get('zh-toggle').title, /分屏对照中/)
+  assert.ok(st.classList.contains('active'))
+})
+
+test('E9 提示文案表（A7/A8/A13 的客户端分档）', () => {
+  const R = loadReader()
+  const note = (resp) => R.t.trNote(resp)
+  R.t.setEq({ source: 'none', equations: [], reason: 'no-mineru-artifact' })
+  assert.match(note({}), /未用 MinerU 转录/)
+  assert.match(note({}), /译文可能不准/)
+  R.t.setEq({ source: 'mineru', equations: [], reason: 'no-equations' })
+  assert.match(note({}), /没有公式块/)
+  R.t.setEq({ source: 'mineru', equations: [], reason: 'bad-artifact' })
+  assert.match(note({}), /产物损坏/)
+  R.t.setEq({ source: 'mineru', equations: [{}], reason: undefined })
+  assert.match(note({ formulaLost: 2, formulaStatus: 'applied' }), /有 2 个公式未原样保留/)
+  assert.match(note({ formulaLost: 0, formulaStatus: 'unavailable', hasBlockIndex: true }), /没能定位到原文公式/)
+  assert.match(note({ formulaLost: 0, formulaStatus: 'partial' }), /部分公式未能还原/)
+  assert.match(note({ formulaLost: 0, formulaStatus: 'unavailable', hasBlockIndex: true, formulaSkipped: 1, formulaApplied: 0 }), /选区太短/, 'A13：全部未还原 + 过短 ⇒ 必须报「选区太短」')
+  assert.match(note({ formulaLost: 0, formulaStatus: 'partial', formulaSkipped: 1, formulaApplied: 1 }), /部分公式未能还原/, '部分还原时先报 partial')
+  assert.equal(note({ formulaLost: 0, formulaStatus: 'applied', formulaApplied: 3, formulaSkipped: 0 }), '', 'applied 时不显示提示')
+  assert.equal(note({ formulaLost: 0, formulaStatus: 'applied', formulaApplied: 0, formulaSkipped: 0 }), '')
+  // 气泡正文永远是纯译文：提示只在 #tr-note（结构断言）
+  assert.ok(!/⚠/.test(READER_HTML.slice(READER_HTML.indexOf('<div id="tr-body">'), READER_HTML.indexOf('<div id="tr-note">'))), '#tr-body 里不得有提示文案')
+})
+
+test('E10 失败反馈表（A10 客户端分档）', () => {
+  const R = loadReader()
+  const f = (e) => ({ ...R.t.trFailure(e) })
+  assert.deepEqual(f({ code: 'timeout' }), { status: '翻译超时，请重试', toast: '翻译超时，请重试' })
+  assert.deepEqual(f({ clientTimeout: true }), { status: '翻译超时，请重试', toast: '翻译超时，请重试' })
+  assert.deepEqual(f({ code: 'network' }), { status: '翻译失败：无法连接端点', toast: '翻译失败：无法连接端点' })
+  assert.deepEqual(f({ upstreamStatus: 401 }), { status: '翻译失败：端点拒绝（请检查 API key）', toast: '翻译失败：端点拒绝（HTTP 401）' })
+  assert.deepEqual(f({ upstreamStatus: 403 }), { status: '翻译失败：端点拒绝（请检查 API key）', toast: '翻译失败：端点拒绝（HTTP 403）' })
+  assert.deepEqual(f({ upstreamStatus: 429 }), { status: '翻译失败：请求过于频繁，稍后再试', toast: '翻译失败：请求过于频繁，稍后再试' })
+  assert.deepEqual(f({ upstreamStatus: 503 }), { status: '翻译失败：端点错误（HTTP 5xx）', toast: '翻译失败：端点错误（HTTP 5xx）' })
+  assert.deepEqual(f({ upstreamStatus: 400, message: '上游返回 HTTP 400：bad model' }), { status: '翻译失败：上游返回 HTTP 400：bad model', toast: '翻译失败：上游返回 HTTP 400：bad model' })
+  assert.deepEqual(f(new Error('boom')), { status: '翻译失败：boom', toast: '翻译失败：boom' })
+})
+
+test('E11 端到端（DOM stub）：划词 → 「译」→ 气泡只显示译文 + 公式进请求体且乱码已清', async () => {
+  const R = loadReader()
+  const idx = buildFormulaIndex(FIXTURE_JSON)
+  R.t.setEq(idx)
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  R.t.setPageMode('scroll')
+  // 页骨架：page > textLayer > span > 文本节点
+  const pageDiv = R.t.makePageNode(1, viewport(), 'orig')
+  R.body.appendChild(pageDiv)
+  const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+  const span = R.doc.createElement('span')
+  tl.appendChild(span)
+  const line = 'The policy \u03c0\u03b8(a|s) maximises the objective J(\u03b8) over the dataset.'
+  const tn = textNode(line)
+  span.appendChild(tn)
+  R.t.paintEqLayer(pageDiv, viewport(), 1)
+
+  // 选中整行 → 既有「选中即问」链路
+  const range = {
+    startContainer: tn, endContainer: tn, startOffset: 0, endOffset: line.length,
+    commonAncestorContainer: tn,
+    intersectsNode: () => true,
+    toString: () => line,
+    cloneRange() { return this },
+    getBoundingClientRect: () => ({ left: 40, top: 100, right: 200, bottom: 112, width: 160, height: 12 }),
+  }
+  R.win.getSelection = () => ({ toString: () => line, anchorNode: tn, isCollapsed: false, getRangeAt: () => range, removeAllRanges() {}, addRange() {} })
+  R.doc.dispatch('mousedown', { target: span, clientX: 10, clientY: 10 })
+  R.doc.dispatch('mouseup', { target: span, clientX: 60, clientY: 12 })
+  await new Promise((r) => setTimeout(r, 30))
+  assert.equal(R.els.get('ask-pop').style.display, 'block', '选中即问必须照旧弹出')
+  assert.equal(R.els.get('ask-translate').style.display, 'inline-block', '原文视图的纯文字选区必须出现「译」')
+  assert.equal(R.els.get('ask-copy').style.display, 'none', '文字选区不得显示复制 LaTeX')
+
+  // 点「译」（记下 innerHTML 写入基线：只有渲染期间的写入才算数。stub 的 innerHTML setter 会累加计数）
+  const htmlWritesBefore = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  await R.els.get('ask-translate').onclick()
+  const htmlWritesAfter = [...R.els.values(), ...R.created].reduce((a, e) => a + (e._innerHTMLWrites || 0), 0)
+  assert.equal(htmlWritesAfter - htmlWritesBefore, 0, '气泡渲染期间绝不允许写 innerHTML')
+  const req = R.requests.find((r) => r.url.endsWith('/api/translate-selection'))
+  assert.ok(req, '必须走 /api/translate-selection')
+  assert.equal(req.body.topic, 'lib')
+  assert.equal(req.body.name, 'paper')
+  assert.ok(Array.isArray(req.body.chunks) && req.body.chunks.length === 1)
+  assert.equal(req.body.chunks[0].kind, 'text')
+  assert.ok(!Object.keys(req.body).some((k) => /key|baseUrl|endpoint/i.test(k)), `请求体不得含 key/端点：${Object.keys(req.body)}`)
+  assert.equal(R.els.get('ask-pop').style.display, 'none', '点「译」后既有气泡必须隐藏')
+  assert.equal(R.els.get('tr-pop').style.display, 'block')
+  // 气泡正文**只有**译文本身（提示走独立的 #tr-note，且本响应的公式全部保留 ⇒ 无提示）。
+  // 新契约：译文切成文本段/数学段 —— 文本段仍逐字进 textContent，数学段渲染成 .tr-math 元素（vendored KaTeX）。
+  const trBody = R.els.get('tr-body')
+  const trSegs = trBody.children
+  const mathSegs = trSegs.filter((e) => e._classes.has('tr-math'))
+  assert.equal(mathSegs.length, 1, `公式段必须渲染成 .tr-math 元素：${trSegs.map((e) => e.className)}`)
+  assert.ok(!mathSegs[0]._classes.has('tr-math-fallback'), '合法 LaTeX 不得走降级分支')
+  assert.ok(/katex/.test(String(mathSegs[0].children[0]?.className ?? '')), 'KaTeX 必须真的往这个元素里建了 DOM')
+  assert.equal(trSegs.filter((e) => !e._classes.has('tr-math')).map((e) => e.textContent).join(''), '这是译文（含 ）',
+    '数学段之外的文字必须逐字保留在 textContent 里（顺序与原文一致）')
+  assert.equal(R.els.get('tr-status').textContent, '', '成功时不得残留「翻译中…」')
+  assert.equal(R.els.get('tr-note').textContent, '', '公式全部保留且渲染成功时不显示提示')
+  assert.equal(htmlWritesAfter - htmlWritesBefore, 0, '气泡渲染路径绝不允许写 innerHTML（模型输出不可信）')
+  // 译文气泡内部零 button（结构）+ 没有把说明文字混进正文
+  assert.ok(!/button/i.test(String(R.els.get('tr-pop').innerHTML ?? '')))
+  assert.ok(!String(R.els.get('tr-body').textContent).includes('⚠'))
+})
+
+test('E14 端到端：formulaLost>0 出「未原样保留」提示；no-endpoint 弹出既有设置浮层（A7/A9）', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  const pageDiv = R.t.makePageNode(1, viewport(), 'orig')
+  R.body.appendChild(pageDiv)
+  const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+  const span = R.doc.createElement('span')
+  tl.appendChild(span)
+  const line = 'si=Encθ(oi)ˆst+1 where t denotes'
+  const tn = textNode(line)
+  span.appendChild(tn)
+  const range = {
+    startContainer: tn, endContainer: tn, startOffset: 0, endOffset: line.length,
+    commonAncestorContainer: tn, intersectsNode: () => true,
+    toString: () => line, cloneRange() { return this },
+    getBoundingClientRect: () => ({ left: 40, top: 100, right: 200, bottom: 112, width: 160, height: 12 }),
+  }
+  R.win.getSelection = () => ({ toString: () => line, anchorNode: tn, isCollapsed: false, getRangeAt: () => range, removeAllRanges() {}, addRange() {} })
+  R.doc.dispatch('mousedown', { target: span, clientX: 10, clientY: 10 })
+  R.doc.dispatch('mouseup', { target: span, clientX: 60, clientY: 12 })
+  await new Promise((r) => setTimeout(r, 30))
+  // ① 模型丢了 1 个公式 → #tr-note 如实提示（A7）
+  R.t.setTrResp({ translation: '译文', formulaTotal: 2, formulaKept: 1, formulaLost: 1, formulaApplied: 1, formulaSkipped: 0, formulaStatus: 'applied', hasBlockIndex: true, model: 'm', cached: false, ms: 1 })
+  await R.els.get('ask-translate').onclick()
+  await new Promise((r) => setTimeout(r, 20))
+  assert.equal(R.els.get('tr-body').textContent, '译文')
+  assert.match(String(R.els.get('tr-note').textContent), /有 1 个公式未原样保留/)
+  // ② 未配置端点 → 打开既有设置浮层（openCfgPop），气泡如实说明
+  R.t.setTrResp({ __status: 503, code: 'no-endpoint', error: '未配置翻译端点：在阅读器里点 ⚙ 填写' })
+  await R.els.get('ask-translate').onclick()
+  await new Promise((r) => setTimeout(r, 20))
+  assert.equal(R.els.get('cfg-pop').style.display, 'block', '未配置端点必须弹出既有设置浮层')
+  assert.match(String(R.els.get('tr-status').textContent), /未配置翻译端点/)
+  // ③ 上游 401 → 气泡状态行与 toast 分档（A10）
+  R.els.get('cfg-pop').style.display = 'none'
+  R.t.setTrResp({ __status: 502, code: 'upstream', upstreamStatus: 401, error: '上游返回 HTTP 401：unauthorized' })
+  await R.els.get('ask-translate').onclick()
+  await new Promise((r) => setTimeout(r, 20))
+  assert.equal(R.els.get('tr-status').textContent, '翻译失败：端点拒绝（请检查 API key）')
+  assert.match(String(R.els.get('toast').textContent), /翻译失败：端点拒绝（HTTP 401）/)
+})
+
+test('E12 端到端（DOM stub）：display 公式选区 → 请求体里没有乱码字符、只有紧凑 LaTeX', async () => {
+  const R = loadReader()
+  const idx = buildFormulaIndex(FIXTURE_JSON)
+  R.t.setEq(idx)
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  const pageDiv = R.t.makePageNode(1, viewport(), 'orig')
+  R.body.appendChild(pageDiv)
+  const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+  const span = R.doc.createElement('span')
+  tl.appendChild(span)
+  R.t.paintEqLayer(pageDiv, viewport(), 1)
+  const geo = R.t.EQ_BY_PAGE.get(1)[0]
+  // 乱码字符（控制字符 + 私用区 + 走音符号）落在公式盒中心
+  const junk = 'si=Enc\u03b8\u0000\u0010\u0011\ue000\u02c6st+1'
+  const tn = textNode(junk)
+  span.appendChild(tn)
+  const cx = (geo.x0 + geo.x1) / 2, cy = (geo.y0 + geo.y1) / 2
+  // 每个字符的 rect 都落在盒中心（模拟公式盒覆盖整行）：覆盖 stub 的 createRange
+  R.doc.createRange = () => ({
+    setStart() {}, setEnd() {},
+    getBoundingClientRect: () => ({ left: cx, top: cy, right: cx + 4, bottom: cy + 4, width: 4, height: 4 }),
+  })
+  const rng = {
+    startContainer: tn, endContainer: tn, startOffset: 0, endOffset: junk.length,
+    commonAncestorContainer: tn, intersectsNode: () => true,
+    toString: () => junk,
+    cloneRange() { return this },
+    getBoundingClientRect: () => ({ left: cx, top: cy, right: cx + 10, bottom: cy + 10, width: 10, height: 10 }),
+  }
+  R.win.getSelection = () => ({ toString: () => junk, anchorNode: tn, isCollapsed: false, getRangeAt: () => rng, removeAllRanges() {}, addRange() {} })
+  R.doc.dispatch('mousedown', { target: span, clientX: cx, clientY: cy })
+  R.doc.dispatch('mouseup', { target: span, clientX: cx + 2, clientY: cy + 2 })
+  await new Promise((r) => setTimeout(r, 30))
+  await R.els.get('ask-translate').onclick()
+  const req = R.requests.find((r) => r.url.endsWith('/api/translate-selection'))
+  assert.ok(req)
+  assert.equal(req.body.chunks.length, 1, '整段乱码字符必须被合成**一个** formula chunk')
+  assert.equal(req.body.chunks[0].kind, 'formula')
+  assert.equal(req.body.chunks[0].latex, R.t.eqLatex(idx.equations[0].latex), '必须是紧凑 LaTeX')
+  assert.ok(!/[\u0000-\u001f\u007f-\u009f\ue000-\uf8ff\ufffd]/.test(JSON.stringify(req.body)), '请求体里不得出现任何乱码字符')
+})
+
+test('E13 既有 /api/ask 请求体字段集合不变（R1 硬红线）', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  const pageDiv = R.t.makePageNode(1, viewport(), 'orig')
+  R.body.appendChild(pageDiv)
+  R.t.paintEqLayer(pageDiv, viewport(), 1)
+  const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+  const span = R.doc.createElement('span')
+  tl.appendChild(span)
+  const tn = textNode('selected body text')
+  span.appendChild(tn)
+  const range = {
+    startContainer: tn, endContainer: tn, startOffset: 0, endOffset: 18,
+    commonAncestorContainer: tn, intersectsNode: () => true,
+    toString: () => 'selected body text', cloneRange() { return this },
+    getBoundingClientRect: () => ({ left: 10, top: 10, right: 100, bottom: 20, width: 90, height: 10 }),
+  }
+  R.win.getSelection = () => ({ toString: () => 'selected body text', anchorNode: tn, isCollapsed: false, getRangeAt: () => range, removeAllRanges() {}, addRange() {} })
+  R.doc.dispatch('mousedown', { target: span, clientX: 10, clientY: 10 })
+  R.doc.dispatch('mouseup', { target: span, clientX: 80, clientY: 10 })
+  await new Promise((r) => setTimeout(r, 30))
+  R.els.get('ask-input').value = '这段什么意思？'
+  await R.els.get('ask-send').onclick()
+  const req = R.requests.find((r) => r.url.endsWith('/api/ask'))
+  assert.ok(req)
+  assert.deepEqual(Object.keys(req.body).sort(), ['name', 'page', 'question', 'selectedText', 'topic'])
+  assert.equal(req.body.selectedText, 'selected body text')
+  assert.equal(req.body.question, '这段什么意思？')
+  // 公式引用链路：kind=equation 时 body 多出 kind/equationIndex，且引用串是 $$ … $$
+  R.win.getSelection = () => null
+  const g = R.t.EQ_BY_PAGE.get(1)[0]
+  R.doc.dispatch('mousedown', { target: pageDiv.children[0], clientX: (g.x0 + g.x1) / 2, clientY: (g.y0 + g.y1) / 2 })
+  R.doc.dispatch('mouseup', { target: pageDiv.children[0], clientX: (g.x0 + g.x1) / 2, clientY: (g.y0 + g.y1) / 2 })
+  await new Promise((r) => setTimeout(r, 30))
+  assert.equal(R.els.get('ask-copy').style.display, 'inline-block')
+  R.els.get('ask-input').value = '这个公式怎么推？'   // showAskPop 会清空输入框，问题文本必须在其后填
+  await R.els.get('ask-send').onclick()
+  const eqReq = R.requests.filter((r) => r.url.endsWith('/api/ask')).pop()
+  assert.deepEqual(Object.keys(eqReq.body).sort(), ['equationIndex', 'kind', 'name', 'page', 'question', 'selectedText', 'topic'])
+  assert.equal(eqReq.body.kind, 'equation')
+  assert.match(eqReq.body.selectedText, /^\$\$ .+ \$\$$/)
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   G. t6 修复回归：t3 独立验证报告的 F1/F2/F3 + 队长裁定的 D1
+      （docs/selection-translate-verification.md §6.1–§6.4、§12）
+   三个缺陷都是「静默送错文本」，所以断言分两层：
+     ① 行为层：该还原的要还原（且**不丢词**），不该还原的必须**原样返回** + 走诚实文案；
+     ② 结构层：钉住机制（openSplit 的 await 顺序、按钮状态），防以后改回去。
+   ══════════════════════════════════════════════════════════════════════════ */
+
+/** F1 合成夹具：模拟 Dong p6 的真实形态——块里公式的 LaTeX 命令名（\mathbf/\left/\right）
+ *  远多于文本层的退化形态（`st = [st, st−1, …]`），这正是「行走预算被 LaTeX 噪声吃光」的成因。 */
+const F1_BLOCK = 'where $\\mathbf { s } _ { t } = \\left[ s _ { t } , s _ { t - 1 } , . . . , s _ { t - k } \\right]$ denotes the sequence of previous latent states and k is the context size.'
+const F1_CHUNK = 'where st = [st, st\u22121, ..., st\u2212k] denotes the sequence'
+
+/** F2 合成夹具：选区所属段落**不在**候选集里，但同页另一个块共享 `learner encoder` 字样。 */
+const F2_JSON = JSON.stringify({ producer: 'mineru', pageCount: 2, contentList: [
+  { type: 'text', page_idx: 0, text: 'During training, an expert encoder distills knowledge while a learner encoder $\\pi _ { \\theta }$ adapts to the task.' },
+  { type: 'text', page_idx: 1, text: 'Expert and learner encoders $\\pi _ { \\theta }$ are trained jointly on the dataset.' },
+] })
+
+test('F1 行内对齐不得丢掉公式跨度前的正文词（合成夹具，零依赖）', () => {
+  const r = alignSelectionToBlock(F1_CHUNK, F1_BLOCK)
+  assert.equal(r.applied, 1, `必须还原（否则用户看到的是乱码）：${JSON.stringify(r)}`)
+  assert.ok(r.text.startsWith('where '), `跨度必须以块里的 where 开头，实际=${JSON.stringify(r.text)}`)
+  assert.ok(r.text.includes('$\\mathbf{s}_t=\\left[s_t,s_{t-1},...,s_{t-k}\\right]$'), '公式必须整段来自块里的紧凑 LaTeX')
+  assert.ok(r.text.endsWith('the sequence'), '跨度末尾不得截断')
+  assert.equal(r.unpairedLetters, '', '不得有未解释的选区字母')
+  assert.equal(r.completedTail, '')
+
+  // 同类边界（都要保住开头那个词）：
+  // ① 公式编号前缀 `(4)` 的裸数字允许留在外面（它不是正文词）
+  const withNum = alignSelectionToBlock(' (4)' + F1_CHUNK, F1_BLOCK)
+  assert.equal(withNum.applied, 1)
+  assert.ok(withNum.text.includes('where'), `公式编号前缀不得吃掉正文词：${withNum.text}`)
+  // ② 选区尾部多一个块外的孤立符号
+  const withDot = alignSelectionToBlock(F1_CHUNK + ' \u00b7', F1_BLOCK)
+  assert.equal(withDot.applied, 1)
+  assert.ok(withDot.text.includes('where'))
+  // ③ 纯正文（块里没有公式）也必须原样、不得引入 $
+  const prose = alignSelectionToBlock('where n denotes total trajectory length', 'where n denotes total trajectory length. Aligning expert and learner encoders improves eficiency.')
+  assert.equal(prose.applied, 1)
+  assert.ok(!/\$/.test(prose.text), `纯正文不得引入 $：${prose.text}`)
+  // ④ 机制不变式：块侧跳过只允许落在 `$…$` 片段内 —— 正文里要求跳字（`alpha gamma delta`）必须拒绝
+  const skipProse = alignSelectionToBlock('alpha gamma delta', 'alpha beta gamma delta epsilon $z _ { t }$ zeta')
+  assert.equal(skipProse.applied, 0, '要跳过正文词才能接上的选区必须拒绝（张冠李戴）')
+  assert.equal(skipProse.reason, 'gate')
+})
+
+test('F2 本段不在候选集里时不得被别的段落接走（合成夹具，零依赖）', () => {
+  const idx = buildTextBlockIndex(F2_JSON)
+  assert.equal(idx.blocks.length, 2)
+  // 反向对照：同页另一个块「共享 learner encoder 字样」，逐块直测也必须拒绝
+  const other = idx.blocks.find((b) => b.page === 2)
+  const direct = alignSelectionToBlock(', while a learner encoder', other.text)
+  assert.equal(direct.applied, 0, `别的段落不得接走它：${JSON.stringify(direct)}`)
+  assert.equal(direct.reason, 'gate')
+  assert.ok(direct.unpairedLetters.length > 0, '必须是因为选区侧有字母没被解释而拒绝')
+
+  for (const chunk of [', while a learner encoder', 'During', 'training,']) {
+    // ① F2：选区落在第 2 页（本段在第 1 页）→ 必须原样送出，applied=0
+    const bad = assembleSource([{ page: 2, kind: 'text', text: chunk }], idx)
+    assert.equal(bad.applied, 0, `${chunk} 不得被别段接走`)
+    assert.equal(bad.source, chunk, '拒绝时必须**原样**返回选区文本')
+    assert.equal(formulaStatusOf(bad), 'unavailable', '诚实降级：状态让客户端出「没能定位到原文公式」提示')
+    // ② 正对照：同一个块在第 1 页（本段就在那里）→ 必须还原（证明不是「一律拒绝」）
+    const good = assembleSource([{ page: 1, kind: 'text', text: chunk }], idx)
+    assert.equal(good.applied, 1, `本段在候选集里时必须还原：${chunk}`)
+    assert.ok(/learner encoder|During|training/.test(good.source), `正对照输出异常：${good.source}`)
+  }
+})
+
+test('F2-续 端点补词门槛：词尾补全必须有换行连字符（`Instruction:` 不得被 `instructions` 接走）', () => {
+  const r = alignSelectionToBlock('Instruction:', 'The instructions are given to the agent.')
+  assert.equal(r.applied, 0, '图注 Instruction: 不得被块里的 instructions 接走（t3 p9 同类现象）')
+  assert.ok(r.completedTail.length > 0, '拒绝原因必须是端点补词越界')
+  // 反向：换行断词（文本层的 `com-` 与下一行 `pact`）**必须**照常还原 —— 那是正常断行，不是缺陷
+  const head = alignSelectionToBlock('we replace high-dimensional RGB images with com-', 'we replace high-dimensional RGB images with compact world-model latents.')
+  assert.equal(head.applied, 1)
+  assert.ok(head.text.endsWith('compact'), `断词前半必须补成完整的 compact：${head.text}`)
+  const tail = alignSelectionToBlock('pact world-model latents.', 'we replace high-dimensional RGB images with compact world-model latents.')
+  assert.equal(tail.applied, 1)
+  assert.ok(tail.text.startsWith('compact'), `断词后半必须接上 compact：${tail.text}`)
+})
+
+test('F1/F2 真实样本：Dong p6 的 where 丢词与三个张冠李戴 chunk（无产物时 skip）', (t) => {
+  if (!REAL_BEST) return t.skip('本机没有真实 MinerU 产物')
+  const raw = REAL_BEST.raw
+  const idx = buildTextBlockIndex(raw)
+  const p6 = idx.blocks.filter((b) => b.page === 6)
+  const f1block = p6.find((b) => b.text.startsWith('where $\\mathbf{s}_t'))
+  if (!f1block) return t.skip('该产物的 p6 形态与本机样本不同（缺 F1 夹具块）')
+  // F1：真实验证方的最小复现（.probe/verify-t3/p2-align-repro.mjs 的 C2/C4）
+  for (const chunk of ['where st = [st, st\u22121, ..., st\u2212k] denotes the sequence', ' (4)where st = [st, st\u22121, ..., st\u2212k] denotes the sequence']) {
+    const r = alignSelectionToBlock(chunk, f1block.text)
+    assert.equal(r.applied, 1, `真实样本必须还原：${chunk}`)
+    assert.ok(r.text.includes('where'), `不得丢掉 where：${r.text}`)
+  }
+  // F2：选区在第 6 页，而它所属的段落（page_idx 属第 5 页）不在第 6 页候选集里
+  for (const chunk of [', while a learner encoder', 'During', 'training,', 'forcing (DF) (Chen et al., 2024; Song et al., 2025) to']) {
+    const asm = assembleSource([{ page: 6, kind: 'text', text: chunk }], idx)
+    assert.equal(asm.applied, 0, `${chunk} 不得被第 6 页的别段接走`)
+    assert.equal(asm.source, chunk, '必须原样返回')
+    for (const b of p6) {
+      assert.equal(alignSelectionToBlock(chunk, b.text).applied, 0, `${chunk} 不得命中任何第 6 页块`)
+    }
+  }
+})
+
+test('F3 刷新后恢复分屏：openSplit 必须先 await ensurePdfjs（pdf.js 未就绪时）', async () => {
+  const R = loadReader()
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  R.t.setZhState({ zh: true, dual: false, busy: false })
+  const urls = []
+  const stubDoc = (n) => ({
+    numPages: n,
+    getPage: async () => ({
+      getViewport: () => viewport(),
+      render: () => ({ promise: Promise.resolve() }),
+      getTextContent: () => ({ items: [] }),
+      destroy: async () => {},
+    }),
+  })
+  const lib = {
+    GlobalWorkerOptions: {},
+    TextLayer: class { async render() {} },
+    getDocument: ({ url }) => { urls.push(url); return { promise: Promise.resolve(stubDoc(2)) } },
+  }
+  R.t.armColdPdfjs(lib)   // 复现时序：pdfjsLib 未就绪，只有 ensurePdfjs 能把它装上
+  R.t.setView('split')
+  await R.t.openSplit()
+  assert.equal(R.t.getView(), 'split', '恢复分屏不得回落到原文')
+  assert.ok(R.t.getPdfDocZh(), '中文列文档必须装上')
+  assert.ok(urls.some((u) => u.includes('variant=zh')), `必须真的拉了 -zh.pdf：${JSON.stringify(urls)}`)
+  assert.ok(urls.some((u) => !u.includes('variant=')), '原文列也要装上')
+  // toast 元素可能还没被创建（没弹过 toast）→ 用 getElementById 取（会自动建）
+  assert.ok(!String(R.doc.getElementById('toast').textContent).includes('打开中文版失败'), '不得出现「pdfjsLib is not defined」类失败提示与回落 toast')
+
+  // 结构层：openSplit 里 `await ensurePdfjs()` 必须早于第一次触 pdfjsLib（与 loadPdf 同一条通道）
+  const at = SCRIPT_SRC.indexOf('async function openSplit')
+  const body = SCRIPT_SRC.slice(at, SCRIPT_SRC.indexOf('\n}\n', at))
+  const atEnsure = body.indexOf('await ensurePdfjs()')
+  const atLib = body.indexOf('pdfjsLib.getDocument')   // 注释里也提到 pdfjsLib，所以盯调用点
+  assert.ok(atEnsure > 0, `openSplit 必须先 await ensurePdfjs（F3）`)
+  assert.ok(atLib > atEnsure, `ensurePdfjs 必须在触 pdfjsLib 之前：ensure@${atEnsure} lib@${atLib}`)
+})
+
+test('D1 无任何变体时「对照/分屏」按钮可见但 disabled，且 title 说明原因（队长裁定）', () => {
+  const R = loadReader()
+  R.t.setCurrent({ topic: 't', name: 'n' })
+  R.t.setZhState({ zh: false, dual: false, busy: false })
+  R.t.updateViewButtons()
+  const dt = R.els.get('dual-toggle'), st = R.els.get('split-toggle')
+  for (const [name, btn, want] of [['对照', dt, /先用「中」生成/], ['分屏', st, /还没有中文版/]]) {
+    assert.notEqual(btn.style.display, 'none', `${name} 按钮必须可见（disabled 而不是隐藏）`)
+    assert.equal(btn.disabled, true, `${name} 按钮必须 disabled`)
+    assert.match(String(btn.title), want, `${name} 按钮的 title 必须说明原因`)
+  }
+  // 有 zh 无 dual：对照仍 disabled 且可见，分屏可用
+  R.t.setZhState({ zh: true, dual: false, busy: false })
+  R.t.updateViewButtons()
+  assert.notEqual(dt.style.display, 'none')
+  assert.equal(dt.disabled, true)
+  assert.equal(st.disabled, false)
+  // 有 dual 无 zh：分屏 disabled，且 title 指出模式 B 需要 -zh.pdf
+  R.t.setZhState({ zh: false, dual: true, busy: false })
+  R.t.updateViewButtons()
+  assert.equal(st.disabled, true)
+  assert.notEqual(st.style.display, 'none')
+  assert.match(String(st.title), /需先生成中文版/)
+  // busy 时两者都 disabled（title 复用阶段说明）
+  R.t.setZhState({ zh: true, dual: true, busy: true, phase: '翻译进行中' })
+  R.t.updateViewButtons()
+  assert.equal(dt.disabled, true)
+  assert.equal(st.disabled, true)
+  assert.match(String(dt.title), /翻译进行中/)
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   H. t7 修复回归：t4 评审的 R-01…R-07（docs/selection-translate-review.md §12）
+   口径与评审一致：**注入变异后这些用例必须变红**（变异证据见任务输出）。
+   ══════════════════════════════════════════════════════════════════════════ */
+
+/** 在某一列的页节点上做一次真实划选（mousedown+mouseup → 既有「选中即问」链路）。 */
+function selectInColumn(R, doc, line, pageNo = 1) {
+  const pageDiv = R.t.makePageNode(pageNo, viewport(), doc)
+  R.body.appendChild(pageDiv)
+  const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+  const span = R.doc.createElement('span')
+  tl.appendChild(span)
+  const tn = textNode(line)
+  span.appendChild(tn)
+  const rect = { left: 40, top: 100, right: 200, bottom: 112, width: 160, height: 12 }
+  const range = {
+    startContainer: tn, endContainer: tn, startOffset: 0, endOffset: line.length,
+    commonAncestorContainer: tn, intersectsNode: () => true,
+    toString: () => line, cloneRange() { return this }, getBoundingClientRect: () => rect,
+  }
+  R.win.getSelection = () => ({ toString: () => line, anchorNode: tn, isCollapsed: false, getRangeAt: () => range, removeAllRanges() {}, addRange() {} })
+  R.doc.dispatch('mousedown', { target: span, clientX: 10, clientY: 10 })
+  R.doc.dispatch('mouseup', { target: span, clientX: 60, clientY: 12 })
+  return pageDiv
+}
+
+const TICK = () => new Promise((r) => setTimeout(r, 30))
+const okResp = (translation) => ({
+  translation, formulaTotal: 1, formulaKept: 1, formulaLost: 0,
+  formulaApplied: 1, formulaSkipped: 0, formulaStatus: 'applied', hasBlockIndex: true,
+  model: 'm', cached: false, ms: 1,
+})
+
+test('R-01 在飞请求必须失效：新选区/换文献后旧响应不得盖到新锚点上', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  selectInColumn(R, 'orig', 'the first paragraph selection')
+  await TICK()
+  assert.equal(R.els.get('ask-translate').style.display, 'inline-block')
+
+  // 挂起这次翻译的响应（慢端点：服务端 30s / 客户端 45s 窗口内用户重选）
+  R.t.setTrResp(okResp('【第一段选区的译文】'))
+  R.ctrl.hold = true
+  const inflight = R.els.get('ask-translate').onclick()
+  await TICK()
+  assert.equal(R.els.get('tr-status').textContent, '翻译中…', '旧请求必须处于在飞状态')
+  assert.equal(R.els.get('tr-body').textContent, '')
+
+  // 用户重新划选（showAskPop 是唯一的「新选区/新引用」入口）→ 在飞请求必须失效
+  const seqBefore = R.t.getTrSeq()
+  selectInColumn(R, 'orig', 'the second paragraph selection', 2)
+  await TICK()
+  assert.ok(R.t.getTrSeq() > seqBefore, `新选区必须使在飞请求失效：${seqBefore} → ${R.t.getTrSeq()}`)
+  R.ctrl.release()
+  await inflight
+  await TICK()
+  assert.ok(!String(R.els.get('tr-body').textContent).includes('第一段选区的译文'), `旧译文不得写进新锚点的气泡：${R.els.get('tr-body').textContent}`)
+  assert.equal(R.els.get('tr-body').textContent, '')
+  assert.notEqual(R.els.get('tr-pop').style.display, 'block', '新选区后译文气泡不得停在可见态')
+  // 失效不能把「译」卡死：busy 必须已复位，新的一次翻译照常出译文
+  assert.equal(R.t.getTrBusy(), false, 'invalidateTranslate 必须复位 busy（否则「译」永久失效）')
+  R.t.setTrResp(okResp('【新选区的译文】'))
+  await R.els.get('ask-translate').onclick()
+  await TICK()
+  assert.equal(R.els.get('tr-body').textContent, '【新选区的译文】', '失效之后必须还能正常翻译')
+})
+
+test('R-01-续 openPaper 换文献同样让在飞请求失效', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.armPdfjs({ GlobalWorkerOptions: {}, TextLayer: class { async render() {} }, getDocument: () => ({ promise: Promise.resolve(docStub(2)) }) })
+  R.t.setCurrent({ topic: 'lib', name: 'A' })
+  selectInColumn(R, 'orig', 'selection on paper A')
+  await TICK()
+  R.t.setTrResp(okResp('【A 的译文】'))
+  R.ctrl.hold = true
+  const inflight = R.els.get('ask-translate').onclick()
+  await TICK()
+  const seqBefore = R.t.getTrSeq()
+  await R.t.openPaper('lib', 'B')          // 换文献
+  assert.ok(R.t.getTrSeq() > seqBefore, `换文献必须使在飞请求失效：${seqBefore} → ${R.t.getTrSeq()}`)
+  R.ctrl.release()
+  await inflight
+  await TICK()
+  assert.equal(R.els.get('tr-body').textContent, '', 'A 的译文不得落到 B 的气泡上')
+})
+
+test('R-02 原地换文献必须先退出分屏（中文列不得留着上一篇）', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setZoom(1)
+  R.t.armPdfjs({ GlobalWorkerOptions: {}, TextLayer: class { async render() {} }, getDocument: () => ({ promise: Promise.resolve(docStub(2)) }) })
+  // 第一篇：真的进分屏（走 openSplit：加 .on、拉两个文档、两列同渲）
+  R.t.setCurrent({ topic: 'lib', name: 'A' })
+  R.t.setZhState({ zh: true, dual: false, busy: false })
+  R.t.setView('split')
+  await R.t.openSplit()
+  const wrap = R.doc.getElementById('split-wrap')
+  assert.ok(wrap.classList.contains('on'), '前置：必须真的进了分屏')
+  assert.ok(R.t.getPdfDocZh(), '前置：中文文档已装上')
+  assert.ok(R.doc.getElementById('pdf-pages-zh').children.length > 0, '前置：中文列有页节点')
+
+  // 换到第二篇：**有 -zh.pdf**（/api/zh 响应 zh:true）且持久化视图不是 split
+  await R.t.openPaper('lib', 'B')
+  assert.equal(R.t.getView(), 'orig', '换文献后视图必须是原文（持久化未记 split）')
+  assert.equal(R.t.getPdfDocZh(), null, '上一篇的中文文档必须释放')
+  assert.ok(!wrap.classList.contains('on'), '分屏容器必须退掉')
+  assert.equal(R.doc.getElementById('pdf-pages-zh').children.length, 0, '中文列页节点必须清空')
+  assert.equal(R.doc.getElementById('pdf-pane-zh').style.display, 'none', '中文列必须隐藏')
+})
+
+test('R-03 文本层里的字面 $ 必须被中和（否则 A7 的公式保全校验被击穿）', () => {
+  const asm = assembleSource(
+    [{ page: 1, kind: 'text', text: 'cost $5 and ' }, { page: 1, kind: 'formula', latex: 'x_t' }],
+    buildTextBlockIndex(null),
+  )
+  assert.equal(asm.source, 'cost \uff045 and $x_t$', `字面 $ 必须中和成全角：${JSON.stringify(asm.source)}`)
+  assert.equal((asm.source.match(/\$/g) ?? []).length % 2, 0, '$ 必须成对')
+  assert.deepEqual(formulaTokens(asm.source), ['$x_t$'], '唯一 token 必须是真的那个公式')
+  // A7 恢复可判定：模型丢掉真公式时必须能报出来
+  assert.deepEqual(verifyFormulas(asm.source, '成本 \uff045 与 $x_t$ 结束'), { total: 1, kept: 1, lost: 0, missing: [] })
+  assert.deepEqual(verifyFormulas(asm.source, '成本 \uff045 与 xt 结束'), { total: 1, kept: 0, lost: 1, missing: ['$x_t$'] })
+  // 两个字面 $ + 一个真公式：不得把 `$5 ... $` 配成假片段
+  const asm2 = assembleSource(
+    [{ page: 1, kind: 'text', text: 'cost $5 and $9 for ' }, { page: 1, kind: 'formula', latex: 'y' }],
+    buildTextBlockIndex(null),
+  )
+  assert.deepEqual(formulaTokens(asm2.source), ['$y$'], `假片段不得出现：${JSON.stringify(formulaTokens(asm2.source))}`)
+  // 对齐成功的那一段（块跨度里的 $…$ 是**真**公式）不得被中和
+  const asm3 = assembleSource([{ page: 1, kind: 'text', text: DEG_B }], IDX)
+  assert.equal(asm3.applied, 1)
+  assert.ok(asm3.source.includes('$\\pi_\\theta(a|s)$'), '块跨度里的真公式必须逐字保留')
+})
+
+test('R-04 网络异常文本必须过 sanitizeDetail（key 不得经响应体到前端）', async () => {
+  const key = 'sk-reviewer-secret-abcdefghijklmnopqrstuvwxyz'
+  const ep = { baseUrl: `https://user:${key}@example.invalid/v1`, apiKey: key, model: 'm' }
+  const err = await translateSelection(ep, 'hello', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: () => { throw new Error(`fetch failed for https://example.invalid/v1?key=${key}`) },
+  }).catch((e) => e)
+  assert.equal(err.code, 'network')
+  assert.ok(!err.message.includes(key), `网络异常文案不得含 key：${err.message}`)
+  assert.ok(err.message.startsWith('无法连接端点：'), `行为文案保持：${err.message}`)
+  const err2 = await translateSelection(ep, 'hello', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: () => { const e = new Error('boom'); e.cause = new Error(`headers: authorization: Bearer ${key}`); throw e },
+  }).catch((e) => e)
+  assert.ok(!err2.message.includes(key), `cause 里的 key 必须被清掉：${err2.message}`)
+  const err3 = await translateSelection(ep, 'hello', {
+    cache: new TranslateSelectionCache(),
+    fetchImpl: () => { const e = new Error('fetch failed'); e.cause = new Error('ECONNREFUSED'); throw e },
+  }).catch((e) => e)
+  assert.match(err3.message, /ECONNREFUSED/, '必须保留可读的失败原因')
+})
+
+test('R-06 三个冻结阈值必须可达（放宽任一个都会被本用例钉住）', () => {
+  // ① ratio 上界（内容口径）：公式的 LaTeX 内容远多于文本层退化形态 ⇒ ratio 出上界，
+  //    且这条夹具的其它闸门都通过（unpaired/端点补词皆空）⇒ 只能是 RATIO_HI 拦下的
+  const upper = alignSelectionToBlock('plan zq( | s, I) then', 'plan $z _ { \\mathrm { plan } } \\sim q _ { \\mathrm { learner } } ( \\cdot | s _ { t } , I _ { c l i p } )$ then')
+  assert.equal(upper.applied, 0, `ratio 上界必须拒绝：${JSON.stringify(upper)}`)
+  assert.ok((upper.ratio ?? 0) > 1.35, `拒绝原因必须是 ratio 超上界：ratio=${upper.ratio}`)
+  assert.equal(upper.unpairedLetters, '', '这条夹具不应由别的门槛解释')
+  assert.equal(upper.completedTail, '')
+  // ② 覆盖门槛（unpaired 字母）：选区里有块里没有的字母 ⇒ 本段不在候选块里
+  const unpaired = alignSelectionToBlock('3 LCVN: Language-Conditioned Vi-', 'language-conditioned visual navigation is a hard task.')
+  assert.equal(unpaired.applied, 0, `unpaired 门槛必须拒绝：${JSON.stringify(unpaired)}`)
+  assert.ok(String(unpaired.unpairedLetters).length > 0, `拒绝原因必须是未解释字母：${unpaired.unpairedLetters}`)
+  // ③ MIN_SCORE 可达：score=0.727 < 0.75，而 ratio 在界内、无未解释字母、无端点补词
+  const lowScore = alignSelectionToBlock('12 3 abcdefgh', 'abcdefgh xxxx')
+  assert.equal(lowScore.applied, 0, `MIN_SCORE 必须可达：${JSON.stringify(lowScore)}`)
+  assert.ok((lowScore.score ?? 1) < 0.75, `score 必须低于阈值：${lowScore.score}`)
+  assert.ok((lowScore.ratio ?? 0) >= 0.6 && (lowScore.ratio ?? 9) <= 1.35, `ratio 必须在界内（否则不是 score 解释的）：${lowScore.ratio}`)
+  assert.equal(lowScore.unpairedLetters, '', '不得由 unpaired 解释')
+  assert.equal(lowScore.completedTail, '', '不得由 completedTail 解释')
+})
+
+test('R-07 分屏中文列的选区不显示「译」（按列禁用），原文列不受影响', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)   // 分屏时 zhVariant 刻意是 null（C17）——所以必须靠 data-doc 判别
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+
+  const zhLine = 'the chinese column line'
+  selectInColumn(R, 'zh', zhLine)
+  await TICK()
+  assert.equal(R.t.getAsk().doc, 'zh', '选区必须记录所在列（data-doc）')
+  assert.equal(R.t.getAsk().text, zhLine, '选中即问本身在中文列仍应正常（只是没有「译」）')
+  assert.equal(R.els.get('ask-pop').style.display, 'block')
+  assert.equal(R.els.get('ask-translate').style.display, 'none', '中文列不得出现「译」')
+  const before = R.requests.filter((r) => String(r.url).endsWith('/api/translate-selection')).length
+  await R.t.translateSelection()
+  assert.equal(R.requests.filter((r) => String(r.url).endsWith('/api/translate-selection')).length, before, '中文列不得发出翻译请求')
+
+  selectInColumn(R, 'orig', 'the original column line', 2)
+  await TICK()
+  assert.equal(R.t.getAsk().doc, 'orig')
+  assert.equal(R.els.get('ask-translate').style.display, 'inline-block', '原文列必须照常出现「译」')
+})
+
+test('R-04-续 testTranslateEndpoint 的 catch 分支同样脱敏（同类既有代码，t4 评审 R-04 的「一并修」）', async () => {
+  // 该路径的 detail 会进 /api/translate/config 的响应体、再上屏（设置浮层）⇒ 必须脱敏。
+  // 用例放在本文件（新的、未跟踪的测试文件）：既有的 test/translate-precheck-redaction.test.mjs
+  // 受 VC1 守卫「既有测试文件零改动」保护，不得修改。
+  const { testTranslateEndpoint } = await import(pathToFileURL(dist('translate-config.js')).href)
+  const key = 'sk-catch-branch-abcdefghijklmnopqrstuvwxyz'
+  const realFetch = globalThis.fetch
+  try {
+    for (const [msg, causeMsg] of [[`fetch failed for http://127.0.0.1:1/v1?key=${key}`, 'ECONNREFUSED'], ['boom', `authorization: Bearer ${key}`]]) {
+      globalThis.fetch = () => { const e = new Error(msg); e.cause = new Error(causeMsg); throw e }
+      const r = await testTranslateEndpoint({ baseUrl: 'http://127.0.0.1:1/v1', apiKey: key, model: 'm' })
+      assert.equal(r.ok, false)
+      assert.equal(r.detail.includes(key), false, `catch 分支不得泄露 apiKey：${r.detail}`)
+      assert.match(r.detail, /ECONNREFUSED|bearer|boom|fetch failed/i, `仍要保留可读原因：${r.detail}`)
+    }
+  } finally {
+    globalThis.fetch = realFetch
+  }
+  // 缺项判断与 happy-path 文案不变（既有的 test/translate-precheck-redaction.test.mjs 继续覆盖）
+  assert.deepEqual(await testTranslateEndpoint({ baseUrl: '', apiKey: 'k', model: 'm' }), { ok: false, detail: '端点配置不完整（需要 url + key + 模型）' })
+})
+
+/* ══════════════════════════════════════════════════════════════════════════
+   I. t9 修复回归：t8 复审的 N-01…N-04（docs/selection-translate-review-r2.md §5）
+   口径同前：**注入回缺陷态后这些用例必须变红**（变异证据见任务输出）。
+   ══════════════════════════════════════════════════════════════════════════ */
+
+test('N-01 openPaper 的失效必须在第一处 await 之前（窗口内旧响应不得点亮气泡）', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.armPdfjs({ GlobalWorkerOptions: {}, TextLayer: class { async render() {} }, getDocument: () => ({ promise: Promise.resolve(docStub(2)) }) })
+  R.t.setCurrent({ topic: 'lib', name: 'A' })
+  selectInColumn(R, 'orig', 'selection on paper A')
+  await TICK()
+  R.t.setTrResp(okResp('【A 的译文】'))
+  R.ctrl.hold = true
+  const inflight = R.els.get('ask-translate').onclick()   // 挂起的旧翻译
+  await TICK()
+  assert.equal(R.els.get('tr-status').textContent, '翻译中…')
+
+  // 换文献：把 openPaper 卡在**第一处 await**（/api/paper）上，模拟 P-A3 的窗口
+  const seqBefore = R.t.getTrSeq()
+  R.ctrl.holdMeta = true
+  const paperP = R.t.openPaper('lib', 'B')   // 故意不 await
+  await TICK()
+  assert.ok(R.t.getTrSeq() > seqBefore, `失效必须发生在第一处 await 之前：${seqBefore} → ${R.t.getTrSeq()}`)
+
+  // 此刻放行旧响应：窗口内到达也不得点亮气泡
+  R.ctrl.release()
+  await inflight
+  await TICK()
+  assert.equal(R.els.get('tr-body').textContent, '', '窗口内到达的旧译文不得写进气泡')
+  assert.notEqual(R.els.get('tr-pop').style.display, 'block', '窗口内不得点亮译文气泡')
+  // 收尾：放行 /api/paper，openPaper 正常走完
+  assert.equal(typeof R.ctrl.releaseMeta, 'function')
+  R.ctrl.releaseMeta()
+  await paperP
+  assert.equal(R.els.get('tr-body').textContent, '')
+})
+
+test('N-02 对齐跨度里的字面 $ 不得配成伪 token（组装期统计 token + 中和）', () => {
+  // 评审 P-F2 的等价夹具：块正文里真的印了两个字面 $（货币写法）+ 一个真公式
+  const J = JSON.stringify({ contentList: [{ type: 'text', page_idx: 0, text: 'the cost is $5 up to $10 then $x _ { t }$ ends' }] })
+  const idx = buildTextBlockIndex(J)
+  const sel = 'the cost is 5 up to 10 then t ends'
+  const asm = assembleSource([{ page: 1, kind: 'text', text: sel }], idx)
+  assert.equal(asm.applied, 1, '前置：这段必须是对齐成功的（缺陷只在**对齐分支**）')
+  // 组装期收集的 token：只含真公式
+  assert.deepEqual(asm.formulaTokens, ['$x_t$'], `组装期 token 必须只含真公式：${JSON.stringify(asm.formulaTokens)}`)
+  // 最终字符串里的 $ 也都成对且都是真公式（字面 $ 已中和成全角）
+  assert.equal(asm.source, 'the cost is \uff045 up to \uff0410 then $x_t$ ends')
+  assert.equal((asm.source.match(/\$/g) ?? []).length % 2, 0)
+  assert.deepEqual(formulaTokens(asm.source), ['$x_t$'], '字符串解析结果必须与组装期列表一致')
+  // 自然翻译（模型丢掉字面 $）**不得**触发假警告：真公式保留 ⇒ lost=0
+  const v = verifyFormulas(asm.source, '花费是 \uff045 到 \uff0410，然后 $x_t$ 结束')
+  assert.deepEqual(v, { total: 1, kept: 1, lost: 0, missing: [] })
+  // 反之，模型真把公式丢了必须报出来（诚实提示不能被这次修复削弱）
+  assert.deepEqual(verifyFormulas(asm.source, '花费是 5 到 10，然后 xt 结束'), { total: 1, kept: 0, lost: 1, missing: ['$x_t$'] })
+  // 显式传 token 列表的入口（路由/组装方用）与字符串解析等价
+  assert.deepEqual(verifyFormulas(asm.source, '花费是 \uff045 到 \uff0410，然后 $x_t$ 结束', asm.formulaTokens), { total: 1, kept: 1, lost: 0, missing: [] })
+  // 未对齐分支的既有行为（R-03）不得回退：字面 $ 全部中和
+  const plain = assembleSource([{ page: 1, kind: 'text', text: 'cost $5 and ' }, { page: 1, kind: 'formula', latex: 'x_t' }], buildTextBlockIndex(null))
+  assert.equal(plain.source, 'cost \uff045 and $x_t$')
+  assert.deepEqual(plain.formulaTokens, ['$x_t$'])
+  // isLatexLikeFragment 的判据（导出给测试）：真公式保留、自然语言片段判为非公式
+  assert.equal(isLatexLikeFragment('$x_t$'), true)
+  assert.equal(isLatexLikeFragment('$F$'), true, '紧凑的纯符号公式必须算 LaTeX（无空白）')
+  assert.equal(isLatexLikeFragment('$5 up to $'), false, '带空白的自然语言片段不算公式')
+  assert.equal(isLatexLikeFragment('$\\text{ s.t. }$'), true, '含命令的片段即使有空白也算公式')
+})
+
+test('N-03 translateSelection 的列判别守卫（第二道防线）必须有自己的覆盖', async () => {
+  const R = loadReader()
+  R.t.setEq(buildFormulaIndex(FIXTURE_JSON))
+  R.t.setVariant(null)
+  R.t.setCurrent({ topic: 'lib', name: 'paper' })
+  // 绕过按钮可见性，直接构造「中文列的选区」并调用入口（模拟将来有人放宽可见性判别）
+  const rangeOver = (pageDiv, line) => {
+    const tl = pageDiv.children.find((c) => c.className === 'textLayer')
+    const tn = tl.children[0].children[0]          // textLayer > span > 文本节点
+    return {
+      startContainer: tn, endContainer: tn, startOffset: 0, endOffset: line.length,
+      commonAncestorContainer: tn, intersectsNode: () => true,
+      toString: () => line, cloneRange() { return this },
+      getBoundingClientRect: () => ({ left: 10, top: 10, right: 100, bottom: 20, width: 90, height: 10 }),
+    }
+  }
+  const zhLine = 'chinese column line'
+  const zhDiv = selectInColumn(R, 'zh', zhLine)
+  await TICK()
+  R.t.setAsk({ text: zhLine, page: 1, kind: 'text', doc: 'zh', range: rangeOver(zhDiv, zhLine) })
+  const before = R.requests.filter((r) => String(r.url).endsWith('/api/translate-selection')).length
+  R.doc.getElementById('toast').textContent = ''
+  await R.t.translateSelection()
+  await TICK()
+  assert.equal(R.requests.filter((r) => String(r.url).endsWith('/api/translate-selection')).length, before, '中文列不得发出翻译请求')
+  assert.equal(String(R.doc.getElementById('toast').textContent), '', '入口守卫必须静默返回（不得弹「选区已失效/页面已重绘」误导文案）')
+  // 对照：原文列同一构造必须照常发请求（证明上面不是因为别的原因静默）
+  const origLine = 'original column line'
+  const origDiv = selectInColumn(R, 'orig', origLine, 2)
+  await TICK()
+  R.t.setAsk({ text: origLine, page: 2, kind: 'text', doc: 'orig', range: rangeOver(origDiv, origLine) })
+  R.t.setTrResp(okResp('【原文列译文】'))
+  await R.t.translateSelection()
+  await TICK()
+  assert.equal(R.requests.filter((r) => String(r.url).endsWith('/api/translate-selection')).length, before + 1, '原文列必须照常请求')
+})
+
+test('N-04 RATIO_LO 可达：只有它能拦下的候选（夹具钉住，改 0 即红）', () => {
+  // 配对落在 LaTeX 命令名（`\beta`）的字母上，contentNormForRatio 把命令名整体剔除 ⇒ 跨度内容长度≈0
+  const r = alignSelectionToBlock('beta', 'the $\\beta$ schedule is warmup')
+  assert.equal(r.applied, 0, `RATIO_LO 必须能把住这个候选：${JSON.stringify(r)}`)
+  assert.equal(r.score, 1, '配对分数是满分（否则不是 RATIO_LO 解释的）')
+  assert.equal(r.ratio, 0, '跨度内容长度为 0')
+  assert.equal(r.unpairedLetters, '', '不得由覆盖门槛解释')
+  assert.equal(r.completedTail, '', '不得由端点补词解释')
+  // 同型：正文里拼写出来的希腊字母
+  const r2 = alignSelectionToBlock('the alpha', 'the $\\alpha$ schedule is warmup')
+  assert.equal(r2.applied, 0)
+  assert.ok((r2.ratio ?? 9) < 0.6, `ratio 必须低于下界（否则不是 RATIO_LO 解释的）：${r2.ratio}`)
+  assert.equal(r2.unpairedLetters, '')
+  assert.equal(r2.completedTail, '')
+  // 反向：真正的公式行不受影响（下界不会误伤正常还原）
+  const ok = alignSelectionToBlock('the beta schedule is warmup', 'the $\\beta$ schedule is warmup')
+  assert.equal(ok.applied, 1)
+  assert.ok(ok.text.includes('$\\beta$'))
+})
+
+// ═══════════════════════════════════════════════════════════════════════════
+// G. 分屏「同步滚动」开关（模式 B）：两处入口 / 全局记忆 / 默认开 / 关掉各自滚 / 重开对齐
+//
+// 验收口径（t1 任务书）：开关在「分屏控件旁」与「设置面板」两处且互相同步；记忆**全局**（不按篇）
+// 且改名不丢；**默认开**；关掉后两列各自独立滚动、重开时对齐回当前页；模式 A（babeldoc -dual.pdf
+// 一个 PDF 里并排嵌好、只有一个滚动条）不受影响；不新增会夺走 textLayer 选区 / 干扰 .eqLayer 的监听。
+//
+// 每条新行为都配一条**能区分它**的用例（括号内是把实现改回缺陷态时该用例的表现）：
+//   G1 默认开 / 关掉后确实不再联动（去掉 `!syncScroll` 早退 → 红）
+//   G2 打开后确实重新对齐（删掉 setSyncScroll 里的 alignSplit → 红）
+//   G3 阅读器侧两处同步（删掉 reader 的 storage 监听 → 红）
+//   G3b 两处互相同步的端到端（两个真实现 + 同一个 localStorage，双向；删任一侧监听或改键 → 红）
+//   G4 设置面板侧两处同步（删掉面板的 storage 监听 / 改成别的键 → 红）
+//   G5 两处同一个键 + 同一套编码（缺省/脏值逐值对照；任一侧改语义 → 红）
+//   G6 全局（不按篇）+ 改名不丢（把键改成 dpr.variant.<topic>/<name> → 红）
+//   G7 模式 A 不受影响、开关不可见且不报错（可见性改成恒显 → 红）
+//   G8 结构性红线（#bar 里的 .tbtn、只加一个 window storage 监听、不碰选区/.eqLayer）
+// ═══════════════════════════════════════════════════════════════════════════
+
+/** 与 reader 的 harness 共用同一个 Map 的 localStorage 实现（含 length/key —— 改名搬家要用）。 */
+function fakeLocalStorage(store) {
+  return {
+    getItem: (k) => (store.has(k) ? store.get(k) : null),
+    setItem: (k, v) => { store.set(k, String(v)) },
+    removeItem: (k) => { store.delete(k) },
+    key: (i) => [...store.keys()][i] ?? null,
+    get length() { return store.size },
+  }
+}
+
+/** 往某一列的 #pdf-pages* 里铺 n 个页节点（offsetTop/offsetHeight 是同步算式的唯一输入）。 */
+function paintColumn(R, boxId, n, { h = 800, startPage = 1 } = {}) {
+  const box = R.doc.getElementById(boxId)
+  box.innerHTML = ''
+  for (let i = 0; i < n; i++) {
+    const d = R.doc.createElement('div')
+    d.className = 'page'
+    d.dataset.page = String(startPage + i)
+    d.offsetTop = i * h
+    d.offsetHeight = h
+    box.appendChild(d)
+  }
+  return box
+}
+
+/** 进入「分屏」态的最小场景：两列各铺若干页 + 挂上各自的滚动监听（不拉真 PDF）。 */
+function enterSplit(R, { n = 5, zhN = 5 } = {}) {
+  R.t.setView('split')
+  R.t.updateViewButtons()          // 与真实路径一致：进分屏先过视图控件状态机（开关可见性/文案在这一处决定）
+  const ob = paintColumn(R, 'pdf-pages', n)
+  const zb = paintColumn(R, 'pdf-pages-zh', zhN)
+  R.t.attachSplitScroll()
+  return { ob, zb, opane: R.doc.getElementById('pdf-pane'), zpane: R.doc.getElementById('pdf-pane-zh') }
+}
+
+const splitAnchor = (R, box, pane) => ({ ...R.t.anchorOf(R.t.columnPages(box), pane.scrollTop) })
+
+test('G1 默认开；关掉（分屏控件旁的开关）后两列各自独立滚动，不再被 rAF 强行对齐', async () => {
+  const R = loadReader()
+  assert.equal(R.t.getSyncScroll(), true, '缺省必须开 —— 等于改造前「两列被 rAF 强行同步」的既有行为')
+  const S = enterSplit(R)
+  // 默认开：滚原文列 → 中文列被 rAF 联动到同页同比例
+  S.opane.scrollTop = 2 * 800 + 400
+  S.opane.onscroll()
+  await TICK()
+  assert.equal(S.zpane.scrollTop, 2 * 800 + 400, '默认开：跟随列必须被联动')
+  assert.equal(R.t.getSplitLead(), S.opane, '主导方 = 用户正在滚的那一列')
+  // 关掉：点分屏控件旁的那个开关
+  R.els.get('sync-toggle').onclick()
+  assert.equal(R.t.getSyncScroll(), false, '点一下必须关掉')
+  assert.equal(R.store.get('dpr.syncScroll'), '0', '必须落持久化（设置面板读的是同一个键）')
+  assert.deepEqual(syncToggleState(R), { icon: 'syncOff', svg: true }, '图标必须跟着状态换成 syncOff（main 的图标集口径）')
+  assert.equal(R.els.get('sync-toggle').classList.contains('active'), false)
+  // 关掉后再滚原文列：中文列一动不动（rAF 联动路径被闸掉）
+  S.zpane.scrollTop = 0
+  S.opane.scrollTop = 4 * 800
+  S.opane.onscroll()
+  await TICK()
+  assert.equal(S.zpane.scrollTop, 0, '关掉后跟随列必须一动不动（不再被强行对齐）')
+  assert.equal(R.t.getSplitLead(), S.opane, '关着的时候仍要记「最后滚过的那一列」（重开对齐要用）')
+  // 反向同样独立：滚中文列不得动原文列
+  S.zpane.scrollTop = 3 * 800 + 100
+  const origBefore = S.opane.scrollTop
+  S.zpane.onscroll()
+  await TICK()
+  assert.equal(S.opane.scrollTop, origBefore, '两列必须各自独立（双向）')
+})
+
+test('G2 重新打开必须对齐回当前页：两列落在同一页同一比例，基准 = 最后滚过的那一列', async () => {
+  // 用户上次关掉了（持久化的关必须被读回）
+  const R = loadReader({ store: new Map([['dpr.syncScroll', '0']]) })
+  assert.equal(R.t.getSyncScroll(), false)
+  const S = enterSplit(R)
+  // 关着的时候两列滚到不同页：原文第 4 页、中文第 1 页
+  S.opane.scrollTop = 3 * 800
+  S.opane.onscroll()
+  await TICK()
+  assert.equal(S.zpane.scrollTop, 0, '关着的时候不许联动')
+  // 打开（分屏控件旁的开关）→ 立即对齐回当前页
+  R.els.get('sync-toggle').onclick()
+  await TICK()
+  assert.equal(R.t.getSyncScroll(), true)
+  assert.equal(S.zpane.scrollTop, 3 * 800, '打开后跟随列必须对齐到当前页（原文第 4 页），不许停在第 1 页')
+  const oa = splitAnchor(R, S.ob, S.opane)
+  const za = splitAnchor(R, S.zb, S.zpane)
+  assert.deepEqual(za, oa, '两列必须落在同一页同一页内比例（否则用户以为坏了）')
+  // 基准 = 最后滚过的那一列：用户在中文列读到第 2 页时重开，原文列要跟过去（而不是把中文列拉回来）
+  R.t.setSyncScroll(false)
+  S.zpane.scrollTop = 1 * 800 + 200
+  S.zpane.onscroll()
+  await TICK()
+  assert.equal(R.t.getSplitLead(), S.zpane)
+  R.t.setSyncScroll(true)
+  await TICK()
+  assert.equal(S.opane.scrollTop, 1 * 800 + 200, '基准必须是「最后滚过的那一列」：原文列跟到中文列当前页')
+  assert.deepEqual(splitAnchor(R, S.ob, S.opane), splitAnchor(R, S.zb, S.zpane))
+  // 页数不同（-zh.pdf 少一页）：按比例映射仍然对齐 + 一次性提示（既有 mismatch 语义不退化）
+  const R2 = loadReader()
+  const S2 = enterSplit(R2, { n: 4, zhN: 3 })
+  S2.opane.scrollTop = 3 * 800
+  R2.t.setSyncScroll(false)
+  R2.t.setSyncScroll(true)
+  await TICK()
+  assert.equal(S2.zpane.scrollTop, 2 * 800, '页数不同按比例映射（第 4/4 页 → 第 3/3 页）')
+  // 刻意保留的行为（设计决定，可被评审挑战）：一次性对齐**不看开关** —— 进分屏/重渲后两列仍落在
+  // 同一页（renderSplit 走的就是 alignSplit）。否则「关着同步打开分屏」会直接停在两页上，
+  // 正是用户说的「会以为坏了」。持续联动（滚动时的 rAF 跟随）才由开关决定（G1 钉住）。
+  const R3 = loadReader({ store: new Map([['dpr.syncScroll', '0']]) })
+  const S3 = enterSplit(R3)
+  S3.zpane.scrollTop = 0
+  S3.opane.scrollTop = 2 * 800 + 400
+  R3.t.alignSplit({ pane: S3.opane, box: S3.ob })
+  await TICK()
+  assert.equal(S3.zpane.scrollTop, 2 * 800 + 400, '一次性对齐与开关无关（进分屏/重渲必须先把两列摆到同一页）')
+  assert.equal(R3.t.getSyncScroll(), false, '一次性对齐不得把开关改掉')
+  // 而持续联动仍然关着（同一次会话里再滚：不动）
+  S3.zpane.scrollTop = 0
+  S3.opane.scrollTop = 4 * 800
+  S3.opane.onscroll()
+  await TICK()
+  assert.equal(S3.zpane.scrollTop, 0, '一次性对齐之后，持续联动仍然是关的')
+})
+
+test('G3 两处开关互相同步（阅读器侧）：设置面板改同一个键 → 阅读器立即跟着变，且不回写不回声', async () => {
+  const R = loadReader()
+  const S = enterSplit(R)
+  assert.deepEqual(syncToggleState(R), { icon: 'sync', svg: true }, '开着 = sync 图标')
+  assert.equal(R.els.get('sync-toggle').style.display, '')     // 分屏下可见（只在分屏下）
+  // 设置面板（另一个文档，同一个 localStorage）关掉 → 阅读器收到 storage 事件
+  R.store.set('dpr.syncScroll', '0')                 // 另一处已经写进去了（这就是 storage 事件的来源）
+  const writes = []
+  const realSet = R.store.set.bind(R.store)
+  R.store.set = (k, v) => { writes.push(k); return realSet(k, v) }
+  R.win.dispatch('storage', { key: 'dpr.syncScroll', newValue: '0' })
+  R.store.set = realSet
+  assert.deepEqual(writes, [], 'storage 事件驱动的那一次不得回写（不回写就不会回声/打架）')
+  assert.equal(R.t.getSyncScroll(), false, '另一处关了 → 阅读器必须立即关')
+  assert.deepEqual(syncToggleState(R), { icon: 'syncOff', svg: true }, '控件状态必须立即反映（图标换到 syncOff）')
+  assert.equal(R.els.get('sync-toggle').classList.contains('active'), false)
+  assert.equal(R.store.get('dpr.syncScroll'), '0', '不得把值改成别的')
+  // 行为立即生效：不再联动
+  S.zpane.scrollTop = 0
+  S.opane.scrollTop = 2 * 800
+  S.opane.onscroll()
+  await TICK()
+  assert.equal(S.zpane.scrollTop, 0, '面板关掉后阅读器必须立刻各自滚')
+  // 面板再打开 → 阅读器立即打开**并对齐回当前页**
+  R.store.set('dpr.syncScroll', '1')
+  R.win.dispatch('storage', { key: 'dpr.syncScroll', newValue: '1' })
+  await TICK()
+  assert.equal(R.t.getSyncScroll(), true)
+  assert.equal(S.zpane.scrollTop, 2 * 800, '面板打开 → 阅读器立即对齐回当前页')
+  // 无关键、同值事件都不得影响
+  R.win.dispatch('storage', { key: 'dpr.pageMode', newValue: '0' })
+  R.win.dispatch('storage', { key: 'dpr.syncScroll', newValue: '1' })
+  assert.equal(R.t.getSyncScroll(), true)
+  // 键被删（newValue = null）→ 回默认「开」
+  R.t.setSyncScroll(false)
+  R.store.delete('dpr.syncScroll')
+  R.win.dispatch('storage', { key: 'dpr.syncScroll', newValue: null })
+  assert.equal(R.t.getSyncScroll(), true, '键被删（null）必须回默认开')
+  // 阅读器里点开关 → 写同一个键（设置面板那一侧靠它读）
+  R.els.get('sync-toggle').onclick()
+  assert.equal(R.store.get('dpr.syncScroll'), '0')
+})
+
+test('G3b 两处互相同步（端到端、两个真实现 + 同一个 localStorage）：阅读器改 → 面板立即反映；面板改 → 阅读器立即反映', async () => {
+  // 一个共享的 localStorage；两侧都是**真实现**：阅读器=真跑 reader 脚本，面板=真跑 client.js 的 apply() 后渲染卡片
+  const store = new Map()
+  const R = loadReader({ store })
+  const S = enterSplit(R)
+  const P = loadSettingsPanel({ store })
+  assert.equal(P.render().input.props.checked, true, '开局两侧都是「开」')
+  // 浏览器的 storage 事件语义：写方之外的每个同源文档都收到 → 这里把「写」与「派发」按方向接起来
+  const pending = []
+  const realSet = store.set.bind(store)
+  store.set = (k, v) => { pending.push([k, String(v)]); return realSet(k, v) }
+  const flushTo = (docWin) => { for (const [k, v] of pending.splice(0)) docWin.dispatch('storage', { key: k, newValue: v }) }
+  // ① 阅读器里点开关（关）→ 面板必须立即跟着取消勾选
+  R.els.get('sync-toggle').onclick()
+  assert.equal(store.get('dpr.syncScroll'), '0', '阅读器必须落持久化')
+  flushTo(P.win)
+  const v1 = P.render()
+  assert.equal(v1.input.props.checked, false, '阅读器改了 → 设置面板必须立即反映')
+  assert.equal(v1.stateKey, 'setSyncScrollOffHint')
+  // ② 面板里勾回来 → 阅读器必须立即跟着打开，并**对齐回当前页**
+  S.zpane.scrollTop = 0
+  S.opane.scrollTop = 3 * 800
+  S.opane.onscroll()
+  await TICK()
+  assert.equal(S.zpane.scrollTop, 0, '此刻还是关着（不联动）')
+  P.render().input.props.onChange({ target: { checked: true } })
+  assert.equal(store.get('dpr.syncScroll'), '1', '面板必须写同一个键')
+  flushTo(R.win)
+  await TICK()
+  assert.equal(R.t.getSyncScroll(), true, '面板改了 → 阅读器必须立即反映')
+  assert.equal(S.zpane.scrollTop, 3 * 800, '面板打开同步 → 阅读器把两列对齐回当前页')
+})
+
+/** 伪 React：只实现本文件渲染要用的那点东西（createElement / Fragment / useState / useEffect / useCallback）。 */
+function makeFakeReact() {
+  const state = []
+  const effects = []
+  let cursor = 0
+  const React = {
+    Fragment: Symbol('dpr-fragment'),
+    createElement(type, props, ...kids) {
+      const children = kids.length === 0 ? undefined : kids.length === 1 ? kids[0] : kids
+      return { type, props: { ...(props || {}), children } }
+    },
+    useState(init) {
+      const i = cursor++
+      if (!(i in state)) state[i] = typeof init === 'function' ? init() : init
+      return [state[i], (v) => { state[i] = typeof v === 'function' ? v(state[i]) : v }]
+    },
+    useEffect(fn) { effects[cursor++] = fn },
+    useCallback(fn) { cursor++; return fn },
+  }
+  return { React, begin() { cursor = 0; effects.length = 0 }, effects }
+}
+
+/** 按 props 递归找节点（**不调用**函数组件，只按属性定位）。 */
+function findNode(node, pred) {
+  if (!node || typeof node !== 'object') return null
+  if (Array.isArray(node)) {
+    for (const n of node) { const hit = findNode(n, pred); if (hit) return hit }
+    return null
+  }
+  if (pred(node)) return node
+  return findNode(node.props && node.props.children, pred)
+}
+
+/** 收集树里所有字符串子节点（文案断言用）。 */
+function collectStrings(node, out = []) {
+  if (typeof node === 'string') { out.push(node); return out }
+  if (!node || typeof node !== 'object') return out
+  if (Array.isArray(node)) { for (const n of node) collectStrings(n, out); return out }
+  collectStrings(node.props && node.props.children, out)
+  return out
+}
+
+/**
+ * 真跑 `lib/client.js` 的 `apply()`（只 stub 宿主 seam：slots/locale/layout/document/window），
+ * 拿到注册进 `settings.section` 的真组件，再用伪 React 渲染其中的「同步滚动」卡片。
+ * 这样测的是**生产代码本身**（不是 grep 出来的字符串）：面板里有没有这一项、读写的键对不对、
+ * 有没有监听 storage 事件（= 与阅读器互相同步的那一半）。
+ */
+function loadSettingsPanel({ store }) {
+  const { React, begin, effects } = makeFakeReact()
+  let loaded = null
+  const win = {
+    __ModuleLoader__: { load: (m) => { loaded = m } },
+    _handlers: {},
+    addEventListener(t, h) { (win._handlers[t] ||= []).push(h) },
+    removeEventListener(t, h) { if (win._handlers[t]) win._handlers[t] = win._handlers[t].filter((x) => x !== h) },
+    dispatch(t, ev) { for (const h of win._handlers[t] || []) h(ev) },
+  }
+  const registered = []
+  const ctx = {
+    window: win,
+    localStorage: fakeLocalStorage(store),
+    console,
+    document: {
+      getElementById: () => null,
+      createElement: () => ({ style: {}, textContent: '', setAttribute() {}, appendChild() {} }),
+      head: { appendChild() {} },
+      addEventListener() {},
+    },
+  }
+  ctx.globalThis = ctx
+  vm.createContext(ctx)
+  vm.runInContext(readFileSync(join(REPO, 'lib', 'client.js'), 'utf8'), ctx, { filename: 'client-settings-inline.js' })
+  assert.ok(loaded && typeof loaded.factory === 'function', 'client.js 必须通过 __ModuleLoader__.load 注册模块')
+  const mod = loaded.factory((name) => (name === 'react' ? React : { createPortal: () => null }))
+  assert.equal(typeof mod.apply, 'function')
+  mod.apply({
+    effect: (fn) => { fn(); return () => {} },
+    locale: { register: () => {}, bind: () => (k) => k },
+    layout: {}, uiWorkspace: {}, sidebarRight: {}, sidebarRightTabs: { register: () => {} },
+    slots: { inject: (name, fn) => { fn() }, register: (def, comp) => { registered.push({ def, comp }); return () => {} } },
+  })
+  const panel = registered.find((r) => r.def && r.def.name === 'settings.section')
+  assert.ok(panel, '必须有 settings.section 注册（设置 → 论文伴读）')
+  const card = findNode(panel.comp(), (n) => typeof n.type === 'function' && n.type.name === 'SyncScrollCard')
+  assert.ok(card, '设置面板里必须有「同步滚动」这一项（卡片）')
+  let mounted = false
+  const render = () => {
+    begin()
+    const out = card.type(card.props)
+    if (!mounted) { mounted = true; for (const fn of effects) if (typeof fn === 'function') fn() }   // 挂 storage 监听
+    return {
+      out,
+      input: findNode(out, (n) => n.props && 'data-dpr-sync-input' in n.props),
+      stateKey: findNode(out, (n) => n.props && 'data-dpr-sync-state' in n.props)?.props.children,
+      texts: collectStrings(out),
+    }
+  }
+  return { render, win, store }
+}
+
+test('G4 设置面板那一项是真的（真跑组件渲染）：默认勾上、可取消、与阅读器同一键、改了立即反映', () => {
+  const store = new Map()
+  const P = loadSettingsPanel({ store })
+  // ① 面板里确实有这一项（与 MinerU/嵌入同款 settings-card），缺省 = 开（默认开）
+  let v = P.render()
+  assert.equal(v.input.props.type, 'checkbox')
+  assert.equal(v.input.props.checked, true, '缺省必须勾上（默认开）')
+  assert.equal(v.stateKey, 'setSyncScrollOnHint', '缺省状态文案必须是「开」那一句')
+  assert.ok(v.texts.includes('setSyncScrollTitle') && v.texts.includes('setSyncScrollDesc') && v.texts.includes('setSyncScrollLabel'), `卡片文案必须走 i18n：${v.texts.join(' | ')}`)
+  // ② 面板里取消 → 写进阅读器读的那个键
+  v.input.props.onChange({ target: { checked: false } })
+  assert.equal(store.get('dpr.syncScroll'), '0', '面板必须写 dpr.syncScroll（阅读器读的就是它）')
+  v = P.render()
+  assert.equal(v.input.props.checked, false)
+  assert.equal(v.stateKey, 'setSyncScrollOffHint')
+  // ③ 阅读器里点开关（另一个文档写同一个键）→ 面板经 storage 事件**立即**反映
+  store.set('dpr.syncScroll', '1')                       // 模拟 /paper-reader/ iframe 里 setItem
+  P.win.dispatch('storage', { key: 'dpr.syncScroll', newValue: '1' })
+  v = P.render()
+  assert.equal(v.input.props.checked, true, '另一处改了 → 面板必须立即反映（否则两处开关不同步）')
+  assert.equal(v.stateKey, 'setSyncScrollOnHint')
+  // ④ 无关键不影响
+  P.win.dispatch('storage', { key: 'dpr.variant.T/P', newValue: '' })
+  assert.equal(P.render().input.props.checked, true)
+  // ⑤ 重新挂载时读的是当前值（不是硬编码）
+  const P2 = loadSettingsPanel({ store: new Map([['dpr.syncScroll', '0']]) })
+  assert.equal(P2.render().input.props.checked, false, '挂载必须读持久化的当前值')
+})
+
+test('G5 两处读同一个键、同一套编码：缺省/脏值逐值对照，写出去的值也一致', () => {
+  const pure = loadClientSyncPure()
+  assert.equal(pure.key, 'dpr.syncScroll')
+  for (const [raw, want] of [['1', true], ['0', false], [undefined, true], ['', true], ['off', true]]) {
+    const store = new Map()
+    if (raw !== undefined) store.set('dpr.syncScroll', raw)
+    const R = loadReader({ store })
+    assert.equal(R.t.getSyncScroll(), want, `阅读器：${JSON.stringify(raw)} → ${want}`)
+    assert.equal(R.t.SYNC_SCROLL_KEY, 'dpr.syncScroll')
+    assert.equal(pure.fromRaw(raw === undefined ? null : raw), want, `设置面板（lib/client.js 纯函数）：${JSON.stringify(raw)} → ${want}`)
+  }
+  assert.equal(pure.raw(true), '1')
+  assert.equal(pure.raw(false), '0')
+  // 面板写出去的值，阅读器必须读回同一个语义（跨实现往返）
+  for (const on of [true, false]) {
+    const s = new Map([['dpr.syncScroll', pure.raw(on)]])
+    assert.equal(loadReader({ store: s }).t.getSyncScroll(), on, `往返：面板写 ${pure.raw(on)} → 阅读器读回 ${on}`)
+  }
+})
+
+test('G6 全局偏好（不按篇）：两篇论文共用一个值；改名搬家（migrateLsKeys）不会碰它', () => {
+  // ① 论文 A 里关掉
+  const R1 = loadReader()
+  R1.t.setCurrent({ topic: 'T1', name: 'P1' })
+  enterSplit(R1)
+  R1.els.get('sync-toggle').onclick()
+  assert.equal(R1.t.getSyncScroll(), false)
+  // 键里不得有 topic/name（有就是「按篇」了）
+  const syncKeys = [...R1.store.keys()].filter((k) => k.startsWith('dpr.sync'))
+  assert.deepEqual(syncKeys, ['dpr.syncScroll'], `同步滚动的键必须是全局的：${syncKeys.join(', ')}`)
+  // 正对照：视图模式（按篇）的键确实带 topic/name —— 证明「全局 vs 按篇」在本用例下可区分
+  assert.match(R1.t.variantKey('T1', 'P1'), /^dpr\.variant\.T1\/P1$/)
+  assert.notEqual(R1.t.variantKey('T1', 'P1'), R1.t.variantKey('T2', 'P2'))
+  // ② 换一篇论文（另一个阅读器文档，共享同一个 localStorage）→ 偏好不被重置
+  const R2 = loadReader({ store: R1.store })
+  R2.t.setCurrent({ topic: 'T2', name: 'P2' })
+  assert.equal(R2.t.getSyncScroll(), false, '换一篇论文后偏好不得被重置（全局）')
+  assert.equal(R2.store.get(R2.t.variantKey('T2', 'P2')) ?? null, null, '正对照：视图模式是按篇的（换论文不会有值）')
+  // ③ 在论文 B 里改成开 → 回到论文 A 依然是同一个值（全局共用一个值）
+  R2.t.setSyncScroll(true)
+  assert.equal(loadReader({ store: R1.store }).t.getSyncScroll(), true)
+  // ④ 改名搬家：真跑 lib/client.js 的 migrateLsKeys —— 只搬 dpr.variant./dpr.sessionN. 两个前缀，
+  //    全局键原样保留（论文改名、专题改名都不丢偏好）
+  const migrate = loadMigrateLsKeys(R1.store)
+  R1.store.set('dpr.variant.T1/P1', 'split')
+  R1.store.set('dpr.sessionN.T1/P1', '3')
+  migrate('T1', 'T2', 'P1', 'P2')
+  assert.equal(R1.store.get('dpr.syncScroll'), '1', '论文改名不得丢全局偏好')
+  assert.equal(R1.store.get('dpr.variant.T2/P2'), 'split', '既有按篇键照常搬家（正对照）')
+  assert.equal(R1.store.get('dpr.sessionN.T2/P2'), '3')
+  migrate('T2', 'T3', null, null)
+  assert.equal(R1.store.get('dpr.syncScroll'), '1', '专题改名不得丢全局偏好')
+  assert.equal(R1.store.get('dpr.variant.T3/P2'), 'split')
+  assert.equal(R1.store.get('dpr.sessionN.T3/P2'), '3')
+})
+
+test('G7 只涉及模式 B：模式 A/原文/译文下开关不可见、点不到、不报错，滚动完全不受影响', () => {
+  const R = loadReader()
+  R.t.setZhState({ zh: true, dual: true, busy: false })
+  // 模式 A（-dual.pdf：一个 PDF 里并排嵌好，只有一个滚动条）
+  R.t.setView('dual')
+  R.t.updateViewButtons()
+  assert.equal(R.els.get('sync-toggle').style.display, 'none', '模式 A 下开关必须不可见')
+  R.els.get('sync-toggle').onclick()                       // 点它：不得报错
+  assert.equal(R.t.getSyncScroll(), true)
+  assert.equal(R.store.has('dpr.syncScroll'), false, '模式 A 下点开关不得写任何偏好')
+  // 双列不存在时两个分屏入口都不得抛，也不得去动中文列
+  const src = { pane: R.doc.getElementById('pdf-pane'), box: R.doc.getElementById('pdf-pages') }
+  R.t.onSplitScroll(src)
+  R.t.alignSplit(src)
+  assert.equal(R.doc.getElementById('pdf-pane-zh').scrollTop, 0, '模式 A 不得被分屏逻辑碰到')
+  // 原文 / 译文视图同样不可见，只有分屏才出现
+  R.t.setView('zh'); R.t.updateViewButtons()
+  assert.equal(R.els.get('sync-toggle').style.display, 'none')
+  R.t.setView('orig'); R.t.updateViewButtons()
+  assert.equal(R.els.get('sync-toggle').style.display, 'none')
+  R.t.setView('split'); R.t.updateViewButtons()
+  assert.equal(R.els.get('sync-toggle').style.display, '', '只有分屏（模式 B）下才可见')
+  // 退出分屏：监听拆掉、主导列作废（再进分屏回到原文列为基准）
+  R.t.setSplitLead(R.doc.getElementById('pdf-pane-zh'))
+  R.t.teardownSplit()
+  assert.equal(R.t.getSplitLead(), null)
+  assert.equal(R.doc.getElementById('pdf-pane').onscroll, null)
+  assert.equal(R.doc.getElementById('pdf-pane-zh').onscroll, null)
+})
+
+test('G8 结构性红线：开关在 #bar 里（覆盖不到选区）、只加一个 window storage 监听、不碰 textLayer/.eqLayer', () => {
+  // ① 分屏控件旁的一个小按钮：同款 .tbtn、有 title（中文 + 英文），紧跟在 #split-toggle 后面
+  const html = READER_HTML
+  const btn = html.match(/<button id="sync-toggle"[^>]*>([^<]*)<\/button>/)
+  assert.ok(btn, '#sync-toggle 必须是 <button>')
+  assert.match(btn[0], /class="tbtn"/, '必须与既有模式切换控件同风格（.tbtn）')
+  // main 的 5fdc51d 把顶栏统一成 inline SVG 图标集：状态用图标表达，所以这里钉「同一套 data-icon 口径」
+  // （图标由 iconHtml 注入，class="ic" + aria-hidden，与其它图标按钮逐字同款），而不是塞回文字标签。
+  assert.match(btn[0], /data-icon="sync"/, '必须走 main 的图标集（data-icon，图标由 iconHtml 注入）')
+  const title = btn[0].match(/title="([^"]+)"/)?.[1] ?? ''
+  assert.ok(title.length > 0, '必须有 title（无文字标签时 title 就是可访问名）')
+  assert.match(title, /同步滚动/, 'zh 文案必须在 title 里')
+  assert.match(title, /Sync scroll/, 'en 文案必须在 title 里')
+  assert.ok(!/[↻⤓▣≣⚙＋−∑‹›]/.test(btn[0]), '不得引入 Unicode 字形（main 刚统一掉的旧样式）')
+  const splitAt = html.indexOf('<button id="split-toggle"')
+  const syncAt = html.indexOf('<button id="sync-toggle"')
+  assert.ok(splitAt >= 0 && syncAt > splitAt, '开关必须在分屏控件旁（紧跟其后）')
+  assert.ok(!html.slice(splitAt, syncAt).includes('<div'), '中间不得插入别的元素（就在分屏控件旁）')
+  assert.ok(syncAt < html.indexOf('<div id="main">'), '必须在顶栏 #bar 里，绝不覆盖 PDF 区（否则夺走 textLayer 拖拽选区）')
+  // ② 新增的这段代码只加**一个**事件监听，且是 window 的 storage（不做任何鼠标/键盘拦截）
+  const block = SCRIPT_SRC.slice(SCRIPT_SRC.indexOf('const SYNC_SCROLL_KEY'), SCRIPT_SRC.indexOf('/** 滚动同步：主导方'))
+  assert.ok(block.length > 200, '同步滚动代码块必须被取到（否则本守卫是空转）')
+  assert.equal((block.match(/addEventListener\(/g) ?? []).length, 1, '只允许一个监听（storage）')
+  assert.match(block, /window\.addEventListener\('storage'/, '那一个监听必须是 window 的 storage（两处同步的唯一通道）')
+  for (const bad of [/document\.addEventListener/, /mouse(up|down)/, /pointer(down|up|move)/, /selectstart/, /dragstart/, /keydown/, /preventDefault/, /stopPropagation/, /textLayer/, /eqLayer/]) {
+    assert.ok(!bad.test(block), `同步滚动不得碰这些东西（会砸掉选区/热区红线）：${bad}`)
+  }
+  // ③ 全脚本里 'storage' 监听恰好一处（不得在别处再挂一份，回声/双写会打架）
+  assert.equal((SCRIPT_SRC.match(/addEventListener\('storage'/g) ?? []).length, 1)
+  // ④ 既有红线复述（一条都不许放宽）：.eqLayer 仍 pointer-events:none；热区层仍不绑事件
+  assert.match(html, /\.eqLayer\s*\{[^}]*pointer-events:\s*none/)
+  assert.ok(!/\.eqLayer[^\n]*addEventListener|eq-box[^\n]*addEventListener/.test(SCRIPT_SRC))
+  // ⑤ 分屏两列仍是各自的滚动监听（R7：不共用滚动容器）
+  const attach = SCRIPT_SRC.slice(SCRIPT_SRC.indexOf('function attachSplitScroll'), SCRIPT_SRC.indexOf('/* ================= 启动'))
+  assert.match(attach, /col\.pane\.onscroll\s*=/, '两列各自 onscroll（不共用容器）')
+  assert.ok(!/addEventListener\('scroll'/.test(attach), '不得改成共用的 scroll 监听')
+  // ⑥ 本功能的两侧 i18n 文案 zh/en 都要有（新增键不得只写一半；F1 另有全量对齐守卫）
+  const client = readFileSync(join(REPO, 'lib', 'client.js'), 'utf8')
+  const zhDict = client.match(/const zh = \{([\s\S]*?)\n    \}/)?.[1] ?? ''
+  const enDict = client.match(/const en = \{([\s\S]*?)\n    \}/)?.[1] ?? ''
+  for (const k of ['setSyncScrollTitle', 'setSyncScrollDesc', 'setSyncScrollLabel', 'setSyncScrollOnHint', 'setSyncScrollOffHint']) {
+    assert.match(zhDict, new RegExp(`${k}: '[^']+'`), `zh 缺文案：${k}`)
+    assert.match(enDict, new RegExp(`${k}: '[^']+'`), `en 缺文案：${k}`)
+  }
+  assert.ok(!new RegExp('t\\(\'setSyncScroll\\w+\'\\)').test(zhDict), 'i18n 文案字典里不得出现 t() 调用')
+  // ⑦ 本文件新增的用例不得有未说明的 skip
+  const mine = readFileSync(fileURLToPath(import.meta.url), 'utf8')
+  const gSection = mine.slice(mine.indexOf('// G. 分屏「同步滚动」开关'))
+  assert.ok(!/\.skip\(/.test(gSection), '新增用例不得有 skip')
+})
+
+/** 执行 lib/client.js 顶层，取「同步滚动」的纯函数（与 reader 的读写必须逐字同义）。 */
+let CLIENT_SYNC_PURE = null
+function loadClientSyncPure() {
+  if (CLIENT_SYNC_PURE) return CLIENT_SYNC_PURE
+  let loaded = null
+  const ctx = { window: { __ModuleLoader__: { load: (m) => { loaded = m } } }, console }
+  vm.createContext(ctx)
+  vm.runInContext(
+    readFileSync(join(REPO, 'lib', 'client.js'), 'utf8')
+      + "\n;globalThis.__dprSyncPure = { key: DPR_SYNC_SCROLL_KEY, fromRaw: dprSyncScrollFromRaw, raw: dprSyncScrollRaw };",
+    ctx, { filename: 'client-sync-inline.js' },
+  )
+  assert.ok(loaded && typeof loaded.factory === 'function', 'client.js 必须通过 __ModuleLoader__.load 注册模块')
+  assert.equal(typeof ctx.__dprSyncPure?.fromRaw, 'function', 'client.js 顶层必须有 dprSyncScrollFromRaw')
+  CLIENT_SYNC_PURE = ctx.__dprSyncPure
+  return CLIENT_SYNC_PURE
+}
+
+/** 取 `src[at]`（一个 `{`）起的配对代码块原文（跳过字符串/注释，避免被文案里的括号骗到）。 */
+function braceBlock(src, at) {
+  assert.equal(src[at], '{', 'braceBlock 必须从 { 开始')
+  let depth = 0
+  let i = at
+  let kind = 'code'
+  while (i < src.length) {
+    const c = src[i]
+    const n = src[i + 1]
+    if (kind === 'code') {
+      if (c === '/' && n === '/') { kind = 'line'; i += 2; continue }
+      if (c === '/' && n === '*') { kind = 'block'; i += 2; continue }
+      if (c === '"' || c === "'" || c === '`') { kind = c; i += 1; continue }
+      if (c === '{') depth += 1
+      else if (c === '}') { depth -= 1; if (depth === 0) return src.slice(at, i + 1) }
+    } else if (kind === 'line') {
+      if (c === '\n') kind = 'code'
+    } else if (kind === 'block') {
+      if (c === '*' && n === '/') { kind = 'code'; i += 2; continue }
+    } else {
+      if (c === '\\') { i += 2; continue }
+      if (c === kind) kind = 'code'
+    }
+    i += 1
+  }
+  throw new Error('braceBlock: 代码块没有闭合')
+}
+
+/** 真跑 lib/client.js 里的 `migrateLsKeys`（改名搬家的唯一实现），在给定的 localStorage 上执行。 */
+function loadMigrateLsKeys(store) {
+  const src = readFileSync(join(REPO, 'lib', 'client.js'), 'utf8')
+  const at = src.search(/function\s+migrateLsKeys\s*\(/)
+  assert.ok(at >= 0, 'lib/client.js 里必须有 migrateLsKeys（改名搬家的唯一实现）')
+  const ctx = { localStorage: fakeLocalStorage(store), JSON, console }
+  const braceAt = src.indexOf('{', at)
+  const decl = src.slice(at, braceAt) + braceBlock(src, braceAt)   // function 头 + 配对代码块
+  vm.createContext(ctx)
+  vm.runInContext(
+    decl + '\n;globalThis.__migrate = migrateLsKeys;',
+    ctx, { filename: 'migrate-inline.js' },
+  )
+  assert.equal(typeof ctx.__migrate, 'function', 'migrateLsKeys 必须能被取到（否则本用例是空转）')
+  return ctx.__migrate
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// H. F1 修（t3）：同步关着时，重渲必须**各自**保住两列的阅读位置
+//
+// 评审 F1 的复现口径：同步关、orig{page2, ratio0.886} / zh{page1, ratio0.501} → 触发一次重渲
+// （zoom / dppx / resize→fitToWidth，三条日常路径都收敛到 renderSplit）→ 中文列的位置被丢弃
+// （两列一起被拉到同一页）。修法：清空前各自记锚点，开关关着时各回各的；开着时行为不变。
+//   H1 #zoom-in/#zoom-out（把修法改回缺陷态 → 红）
+//   H2 resize→fitToWidth（同上 → 红）
+//   H3 dppx（mq change）（同上 → 红）
+//   H4 同步**开着** + zoom 仍统一对齐（把修法套到开着的情形 → 红）
+//   H5 已裁定语义：进分屏一次性对齐不看开关 + paged↔scroll 不可比时统一对齐（闸门放宽 → 红）
+//   H6 关掉后，**在飞的**联动回调不得再拉列（去掉 rAF 体内的开关判定 → 红）
+// ═══════════════════════════════════════════════════════════════════════════
+
+const PAGE_H = 800
+
+/** F1 场景：真跑 renderSplit 的「分屏」+ 两列的真实页几何（假布局 _pageH：每页 800px）。
+ *  滚动范围按「页数 × 页高」给（真实浏览器里由排版算出来）。 */
+async function splitScene({ n = 5, zhN = 5, sync = false, scale = 1.5 } = {}) {
+  const R = loadReader({ store: new Map([['dpr.syncScroll', sync ? '1' : '0']]) })
+  R.t.setView('split')
+  R.t.updateViewButtons()
+  R.t.setPageMode('scroll')
+  R.t.setZoom(scale)
+  R.t.setPdfDoc(docStub(n))
+  R.t.setPdfDocZh(docStub(zhN))
+  const ob = R.doc.getElementById('pdf-pages')
+  const zb = R.doc.getElementById('pdf-pages-zh')
+  ob._pageH = PAGE_H
+  zb._pageH = PAGE_H
+  const opane = R.doc.getElementById('pdf-pane')
+  const zpane = R.doc.getElementById('pdf-pane-zh')
+  opane.clientHeight = PAGE_H
+  zpane.clientHeight = PAGE_H
+  await R.t.renderSplit()          // 进分屏首渲（与 openSplit 同一个入口；中文列这时还没有位置可比）
+  opane.scrollHeight = n * PAGE_H  // 假布局不产出 scrollHeight，按页数给一个口径一致的值
+  zpane.scrollHeight = zhN * PAGE_H
+  R.t.attachSplitScroll()          // 与 openSplit 一致：两列各自挂滚动监听
+  await TICK()                     // 等首渲的「一次性对齐」（rAF）落地：否则 splitSyncing 还挂着 true
+  return { R, ob, zb, opane, zpane }
+}
+
+/** 同步开关的可见状态：main 的图标集下由「图标 + active + title」表达（没有文字标签）。
+ *  icon = 按钮的 data-icon（updateSyncToggle 跟着渲染出来的图标走）；svg = iconHtml 真的注入了 svg。 */
+const syncToggleState = (R) => {
+  const b = R.els.get('sync-toggle')
+  return { icon: b.dataset.icon, svg: /<svg class="ic"/.test(b.innerHTML) }
+}
+
+/** 锚点 = 「顶部页号 + 页内比例」（评审 F1 的测量口径）。 */
+function anchorAt(R, box, pane) { return { ...R.t.anchorOf(R.t.columnPages(box), pane.scrollTop) } }
+const roundAnchor = (a) => ({ page: a.page, ratio: Math.round(a.ratio * 1000) / 1000 })
+
+/** 把两列摆成「读不同位置」——F1 复现用的那组值（原文第 2 页 0.886 / 中文第 1 页 0.501）。 */
+function divergeColumns(S, { origPage = 2, origRatio = 0.886, zhPage = 1, zhRatio = 0.501 } = {}) {
+  S.opane.scrollTop = (origPage - 1) * PAGE_H + origRatio * PAGE_H
+  S.zpane.scrollTop = (zhPage - 1) * PAGE_H + zhRatio * PAGE_H
+  return { orig: anchorAt(S.R, S.ob, S.opane), zh: anchorAt(S.R, S.zb, S.zpane) }
+}
+
+test('H1 【F1】同步关 + #zoom-in/#zoom-out：两列各自保住阅读位置（中文列不再被拉走）', async () => {
+  const S = await splitScene({ sync: false })
+  assert.equal(S.R.t.getSyncScroll(), false)
+  const before = divergeColumns(S)
+  assert.deepEqual(roundAnchor(before.orig), { page: 2, ratio: 0.886 }, '前置：原文列在第 2 页 0.886（评审那组实测值）')
+  assert.deepEqual(roundAnchor(before.zh), { page: 1, ratio: 0.501 }, '前置：中文列在第 1 页 0.501')
+  // 真回调：#zoom-in → exitFitMode() + setZoom(+0.25) → rerender() → renderSplit()
+  S.R.els.get('zoom-in').onclick()
+  await TICK()
+  assert.deepEqual(anchorAt(S.R, S.ob, S.opane), before.orig, '同步关：原文列必须回到自己的位置')
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), before.zh, '同步关：中文列必须保住自己的位置（F1 的复现点）')
+  assert.notDeepEqual(anchorAt(S.R, S.zb, S.zpane), anchorAt(S.R, S.ob, S.opane), '两列不得被拉到同一页')
+  // 反向缩放同样各回各的
+  S.R.els.get('zoom-out').onclick()
+  await TICK()
+  assert.deepEqual(anchorAt(S.R, S.ob, S.opane), before.orig)
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), before.zh)
+  assert.equal(S.R.t.getSyncScroll(), false, '缩放不得改开关')
+})
+
+test('H2 【F1】同步关 + resize→fitToWidth：两列各自保住阅读位置', async () => {
+  const S = await splitScene({ sync: false })
+  // 真实 resize 路径的前置条件：fitMode = true（点击「适宽」就是把它置真；分屏下 fitMode 本来就是真）
+  S.R.els.get('zoom-fit').onclick()
+  await TICK()
+  const before = divergeColumns(S, { origPage: 3, origRatio: 0.25, zhPage: 2, zhRatio: 0.75 })
+  assert.deepEqual(roundAnchor(before.orig), { page: 3, ratio: 0.25 })
+  assert.deepEqual(roundAnchor(before.zh), { page: 2, ratio: 0.75 })
+  // 真回调：window resize → fitMode ⇒ fitToWidth() → setZoom → rerender() → renderSplit()
+  S.R.win.dispatch('resize')
+  await TICK()
+  assert.deepEqual(anchorAt(S.R, S.ob, S.opane), before.orig, 'resize：原文列回到自己的位置')
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), before.zh, 'resize：中文列必须保住自己的位置')
+})
+
+test('H3 【F1】同步关 + dppx（设备像素比）变化：两列各自保住阅读位置', async () => {
+  const S = await splitScene({ sync: false })
+  const before = divergeColumns(S)
+  const mqsBefore = S.R.win._mqs.length
+  // 真回调：watchDpr 的 matchMedia change → dpr = window.devicePixelRatio → rerender() → renderSplit()
+  S.R.win.devicePixelRatio = 2
+  S.R.win._mqs.at(-1).fire('change')
+  await TICK()
+  assert.deepEqual(anchorAt(S.R, S.ob, S.opane), before.orig, 'dppx：原文列回到自己的位置')
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), before.zh, 'dppx：中文列必须保住自己的位置')
+  assert.equal(S.R.win._mqs.length, mqsBefore + 1, 'watchDpr 必须在 change 后重建 mq（否则下一次 dpr 变化追不上）')
+})
+
+test('H4 【防回归】同步开着 + zoom：仍然统一对齐（既有语义不变，不得各回各的）', async () => {
+  const S = await splitScene({ sync: true })
+  assert.equal(S.R.t.getSyncScroll(), true)
+  const before = divergeColumns(S)
+  S.R.els.get('zoom-in').onclick()
+  await TICK()
+  const oa = anchorAt(S.R, S.ob, S.opane)
+  const za = anchorAt(S.R, S.zb, S.zpane)
+  assert.deepEqual(oa, before.orig, '同步开着：原文列仍是自己的位置（既有语义）')
+  assert.deepEqual(za, oa, '同步开着：中文列必须与原文列统一对齐（不得各回各的）')
+  assert.notDeepEqual(za, before.zh, '同步开着：中文列不该停在自己那个旧位置（否则等于把开关偷偷关了）')
+})
+
+test('H5 【已裁定语义】进分屏的一次性对齐不看开关；paged↔scroll 形态变化时仍统一对齐', async () => {
+  // ① 「刚进分屏」（中文列还没有可比的位置：openSplit → renderSplit 时 zh 列是空的）：
+  //    即使同步关着，也必须先把两列摆到同一页 —— t2 评审已裁定这条必要，本修法不得动它。
+  const S = await splitScene({ sync: false })
+  S.opane.scrollTop = 2 * PAGE_H          // 原文列停在第 3 页
+  S.zb.innerHTML = ''                     // 中文列清空 = 「还没有自己的位置」（等价于刚进分屏）
+  await S.R.t.renderSplit()
+  await TICK()                            // 统一对齐走 rAF（alignSplit），等它落地
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), anchorAt(S.R, S.ob, S.opane),
+    '刚进分屏：中文列必须先对齐到原文列（一次性对齐不看开关）')
+  assert.equal(S.R.t.getSyncScroll(), false, '一次性对齐不得改开关')
+  // ② 形态变化（翻页 → 滚动）：重渲前中文列只有 1 页，与这次要渲的 5 页不可比 ⇒ 沿用统一对齐
+  //    （否则「关着同步从翻页切回滚动」会留下两列停在不同页的表象）。两列在单页内先摆成不同的位置，
+  //    这样「统一对齐」与「各回各的」才可区分。
+  S.R.t.setPageMode('paged')
+  S.R.t.setCurPage(2)
+  await S.R.t.renderSplit()
+  assert.equal(S.R.t.columnPages(S.zb).length, 1, '翻页模式两列各 1 页')
+  S.zpane.scrollHeight = PAGE_H
+  S.opane.scrollTop = 0.375 * PAGE_H      // 原文列：这一页滚到 37.5%
+  S.zpane.scrollTop = 0                   // 中文列：这一页顶部（两列位置不同）
+  S.R.t.setPageMode('scroll')
+  await S.R.t.renderSplit()
+  await TICK()                            // 同上：统一对齐是 rAF 的
+  const oa = anchorAt(S.R, S.ob, S.opane)
+  assert.deepEqual(roundAnchor(oa), { page: 1, ratio: 0.375 }, '原文列按滚动比例回位（既有口径）')
+  assert.deepEqual(anchorAt(S.R, S.zb, S.zpane), oa,
+    'paged→scroll：形态不可比 ⇒ 仍统一对齐到原文列（不得各回各的、停在两页上）')
+})
+
+test('H6 【同一族】关掉同步后，在飞的联动回调不得再把中文列拉走', async () => {
+  const S = await splitScene({ sync: true })
+  S.zpane.scrollTop = 0
+  S.opane.scrollTop = 2 * PAGE_H
+  S.opane.onscroll()                      // 用户滚原文列：排了一个 rAF 跟随回调
+  S.R.t.setSyncScroll(false)              // 同一帧内关掉（按钮点击/面板同步都走这一条）
+  await TICK()                            // 排队的回调在这一帧执行
+  assert.equal(S.zpane.scrollTop, 0, '关掉后，在飞的回调也不得再拉列（否则「各自独立」在下一帧被自己打破）')
+  assert.equal(S.R.t.getSyncScroll(), false)
+})
+
+test('H7 锚点捕获/恢复的保真度：几何变了（页高缩放）也必须回到**同一页**，不按比例漂移', () => {
+  const R = loadReader()
+  const box = R.doc.getElementById('pdf-pages')
+  const pane = R.doc.getElementById('pdf-pane')
+  pane.clientHeight = 800
+  // 重渲前：5 页 × 800px，原文列在第 3 页 0.886
+  const paint = (h) => {
+    box.innerHTML = ''
+    for (let i = 0; i < 5; i++) {
+      const d = R.doc.createElement('div')
+      d.className = 'page'
+      d.dataset.page = String(i + 1)
+      d.offsetTop = i * h
+      d.offsetHeight = h
+      box.appendChild(d)
+    }
+    pane.scrollHeight = 5 * h
+  }
+  paint(800)
+  pane.scrollTop = 2 * 800 + 0.886 * 800
+  const a = R.t.captureScrollAnchor(pane, box)
+  assert.deepEqual(roundAnchor(a), { page: 3, ratio: 0.886 }, '捕获必须是「页号 + 页内比例」')
+  // 缩放后（页高变大、滚动范围随之变化）：恢复必须落在同一页同一比例
+  paint(933)
+  R.t.restoreScrollAnchor(pane, box, a)
+  assert.deepEqual(roundAnchor(R.t.anchorOf(R.t.columnPages(box), pane.scrollTop)), { page: 3, ratio: 0.886 },
+    '几何变化后必须回到同一页（纯按比例回位会漂到别的页）')
+  // 页节点不可用时退回滚动比例锚点（并发重渲刚好清空过容器）：绝不把锚点归零成「回到第一页」
+  const box2 = R.doc.getElementById('pdf-pages-zh')
+  const empty = R.t.captureScrollAnchor(pane, box2)
+  assert.equal(empty.page, undefined, '空容器只能给比例锚点')
+  assert.ok(empty.ratio > 0, `空容器也要保住比例（不得归零）：${JSON.stringify(empty)}`)
+})