paperlint 4.0.0 → 4.2.0

package/src/adapters/latex/index.test.ts

@@ -0,0 +1,535 @@
+/**
+ * The LaTeX adapter on real parses: the class line in each of its states, a preset's template, the
+ * class `paperlint new` writes, the outline, and the rendered text. Trees come only from
+ * `parseLatex`; the one helper that reads a node's position is tested on the shapes a position can
+ * take.
+ */
+import type * as Ast from "@unified-latex/unified-latex-types";
+import { describe, expect, it } from "vitest";
+import { runText, spanIn, type ProsePiece } from "../../domain/tex-document.ts";
+import {
+  bodyProse,
+  documentBodyOf,
+  documentClassOf,
+  includesOf,
+  inPlace,
+  latexReader,
+  macroPlace,
+  mandatory,
+  optional,
+  outlineOf,
+  parseLatex,
+  parseTemplate,
+  placeOf,
+  renderedRuns,
+  replaceDocumentClass,
+  textOf,
+} from "./index.ts";
+
+const IEEE = { cls: "IEEEtran", options: ["conference", "compsoc"] };
+
+describe("documentClassOf — the class line's three states", () => {
+  it("a class: each option whitespace-collapsed, and the span of the whole macro, arguments included", () => {
+    const src = "% x\n\\documentclass[ conference ,\n compsoc]{IEEEtran}\n";
+    expect(documentClassOf(parseLatex(src))).toEqual({
+      kind: "class",
+      cls: "IEEEtran",
+      options: ["conference", "compsoc"],
+      place: {
+        kind: "at",
+        span: { start: 4, end: src.indexOf("}") + 1 },
+      },
+    });
+  });
+
+  it("🔴 empty: \\documentclass{} names no class, and stands where it stands — not missing", () => {
+    expect(documentClassOf(parseLatex("%\n\\documentclass{}\n"))).toEqual({
+      kind: "empty",
+      place: { kind: "at", span: { start: 2, end: 16 } },
+    });
+  });
+
+  it("ambiguous: two \\documentclass lines behind a switch, each read as a candidate in source order", () => {
+    const src =
+      "\\if\\x1\\documentclass{article}\\fi\\if\\x2\\documentclass[a]{b}\\fi";
+    const line = documentClassOf(parseLatex(src));
+    expect(
+      line.kind === "ambiguous" &&
+        line.candidates.map((c) => c.kind === "class" && c.cls),
+    ).toEqual(["article", "b"]);
+  });
+
+  it("missing: no \\documentclass at the top of the tree", () => {
+    expect(
+      documentClassOf(parseLatex("\\begin{document}\\end{document}")),
+    ).toEqual({ kind: "missing" });
+  });
+
+  it("a group in the class name and a paragraph break are read as text", () => {
+    const line = documentClassOf(parseLatex("\\documentclass{{IEEE}\n\ntran}"));
+    expect(line.kind === "class" && line.cls).toBe("IEEE tran");
+  });
+});
+
+describe("placeOf / macroPlace — a node the parser gave no position is unplaced, never offset 0", () => {
+  const at = (start: number, end: number) => ({
+    start: { offset: start, line: 1, column: start + 1 },
+    end: { offset: end, line: 1, column: end + 1 },
+  });
+  it("placeOf: a position is a span; none is unplaced", () => {
+    expect(placeOf({ position: at(3, 7) })).toEqual({
+      kind: "at",
+      span: { start: 3, end: 7 },
+    });
+    expect(placeOf({})).toEqual({ kind: "unplaced" });
+  });
+
+  it("macroPlace: unplaced without a position; with one, to past the last argument that holds text", () => {
+    const bare: Ast.Macro = { type: "macro", content: "documentclass" };
+    expect(macroPlace(bare)).toEqual({ kind: "unplaced" });
+    const withArgs: Ast.Macro = {
+      type: "macro",
+      content: "section",
+      position: at(0, 8),
+      args: [
+        { type: "argument", content: [], openMark: "", closeMark: "" },
+        {
+          type: "argument",
+          content: [{ type: "string", content: "A", position: at(9, 10) }],
+          openMark: "{",
+          closeMark: "}",
+        },
+        { type: "argument", content: [], openMark: "[", closeMark: "]" },
+      ],
+    };
+    expect(macroPlace(withArgs)).toEqual({
+      kind: "at",
+      span: { start: 0, end: 11 },
+    });
+  });
+});
+
+describe("a macro with no arguments, and markup in a name", () => {
+  const bare: Ast.Macro = { type: "macro", content: "foo" };
+  it("has no mandatory or optional arguments, and its place is its name", () => {
+    expect(mandatory(bare)).toEqual([]);
+    expect(optional(bare)).toBe(undefined);
+    expect(
+      macroPlace({
+        ...bare,
+        position: {
+          start: { offset: 2, line: 1, column: 3 },
+          end: { offset: 6, line: 1, column: 7 },
+        },
+      }),
+    ).toEqual({ kind: "at", span: { start: 2, end: 6 } });
+  });
+
+  it("textOf drops markup it cannot read as text, and reads nothing as empty", () => {
+    expect(textOf([bare, { type: "string", content: "x" }])).toBe("x");
+    expect(textOf(undefined)).toBe("");
+  });
+});
+
+describe("parseTemplate — a preset's template", () => {
+  it.each<[string, { cls: string; options: string[] } | null]>([
+    ["\\documentclass[conference,compsoc]{IEEEtran}", IEEE],
+    ["article", { cls: "article", options: [] }],
+    [" acmart\n", { cls: "acmart", options: [] }],
+    ["two words", null],
+    ["% c\n\\documentclass{article}\n", { cls: "article", options: [] }],
+    ["\\documentclass{article} trailing", null],
+    ["\\documentclass[a]{}", null],
+    ["", null],
+  ])("%j → %j", (text, want) => {
+    expect(parseTemplate(text)).toEqual(want);
+  });
+});
+
+const replaced = (src: string) => replaceDocumentClass(parseLatex(src), IEEE);
+
+describe("replaceDocumentClass — the class `paperlint new` writes", () => {
+  it("replaces the whole line, arguments included, and keeps everything around it", () => {
+    expect(replaced("% c\n\\documentclass[11pt]{article}\n\\title{x}\n")).toBe(
+      "% c\n\\documentclass[conference,compsoc]{IEEEtran}\n\\title{x}\n",
+    );
+  });
+
+  it("a class that already satisfies the template keeps the author's own options", () => {
+    const src = "\\documentclass[compsoc,conference,a4paper]{IEEEtran}\nx";
+    expect(replaced(src)).toBe(src);
+  });
+
+  it("the right class missing a required option keeps the author's options and adds the missing ones", () => {
+    expect(
+      replaced("\\documentclass[review,anonymous,conference]{IEEEtran}\nx"),
+    ).toBe("\\documentclass[review,anonymous,conference,compsoc]{IEEEtran}\nx");
+  });
+
+  it("an option with a braced value keeps its braces, its commas and its spacing", () => {
+    expect(replaced("\\documentclass[review, foo={a,b}]{IEEEtran}\nx")).toBe(
+      "\\documentclass[review, foo={a,b},conference,compsoc]{IEEEtran}\nx",
+    );
+  });
+
+  it("🔴 a source with several \\documentclass lines is returned as it is: which branch builds is not known", () => {
+    const src =
+      "\\if\\x1\\documentclass{article}\\fi\\if\\x2\\documentclass{IEEEtran}\\fi";
+    expect(replaced(src)).toBe(src);
+  });
+
+  it("no class, or an empty one, is returned as it is", () => {
+    expect(replaced("just text")).toBe("just text");
+    expect(replaced("\\documentclass{}\nx")).toBe("\\documentclass{}\nx");
+  });
+
+  it("the port does the same over a source", () => {
+    expect(
+      latexReader.withDocumentClass("\\documentclass{article}", IEEE),
+    ).toBe("\\documentclass[conference,compsoc]{IEEEtran}");
+  });
+});
+
+describe("replaceDocumentClass — missing options are added in place, the author's bytes kept", () => {
+  it("🔴 the missing options go before the `]`: the author's bytes, a comment included, stay as written", () => {
+    expect(replaced("\\documentclass[foo=bar% note\nbaz]{IEEEtran}\nx")).toBe(
+      "\\documentclass[foo=bar% note\nbaz,conference,compsoc]{IEEEtran}\nx",
+    );
+    const acm = "\\documentclass[review,% reason\nanonymous]{acmart}\nx";
+    expect(
+      replaceDocumentClass(parseLatex(acm), {
+        cls: "acmart",
+        options: ["sigconf"],
+      }),
+    ).toBe("\\documentclass[review,% reason\nanonymous,sigconf]{acmart}\nx");
+  });
+
+  it("a trailing comment in the options: the missing ones go on the next line, before the `]`", () => {
+    expect(replaced("\\documentclass[review% c\n]{IEEEtran}")).toBe(
+      "\\documentclass[review% c\n,conference,compsoc]{IEEEtran}",
+    );
+  });
+
+  it("no options, an empty `[]`, a blank `[ ]`: the options are written without a stray comma", () => {
+    expect(replaced("\\documentclass{IEEEtran}\nx")).toBe(
+      "\\documentclass[conference,compsoc]{IEEEtran}\nx",
+    );
+    expect(replaced("\\documentclass[]{IEEEtran}")).toBe(
+      "\\documentclass[conference,compsoc]{IEEEtran}",
+    );
+    expect(replaced("\\documentclass[ ]{IEEEtran}")).toBe(
+      "\\documentclass[ conference,compsoc]{IEEEtran}",
+    );
+  });
+
+  it("reading the options: a line comment joins its two sides with no space, as TeX does", () => {
+    const read = (src: string) => {
+      const line = documentClassOf(parseLatex(src));
+      return line.kind === "class" && line.options;
+    };
+    expect(read("\\documentclass[review,% reason\nanonymous]{acmart}")).toEqual(
+      ["review", "anonymous"],
+    );
+    expect(read("\\documentclass[foo=bar% note\nbaz]{IEEEtran}")).toEqual([
+      "foo=barbaz",
+    ]);
+  });
+});
+
+describe("outlineOf — a heading's title", () => {
+  it("keeps the text of formatting macros and drops keys such as a label", () => {
+    const o = outlineOf(
+      parseLatex("\\section*{LLM \\textbf{Usage} Statement\\label{s:llm}}"),
+    );
+    expect(o.sections.map((h) => h.title)).toEqual(["LLM Usage Statement"]);
+  });
+});
+
+describe("outlineOf — a formatting macro's text is its last mandatory argument", () => {
+  it.each<[string, string]>([
+    [
+      "\\section*{\\textcolor{red}{LLM Usage Statement}}",
+      "LLM Usage Statement",
+    ],
+    [
+      "\\section*{LLM \\emph{Usage} \\textbf{Statement}}",
+      "LLM Usage Statement",
+    ],
+    ["\\section*{See \\href{https://x.org}{the site}}", "See the site"],
+    [
+      "\\section*{\\texorpdfstring{LLM Usage Statement}{Short}}",
+      "LLM Usage Statement",
+    ],
+    ["\\section*{\\color{red}LLM Usage Statement}", "LLM Usage Statement"],
+    ["\\section*{LLM~Usage~Statement}", "LLM Usage Statement"],
+    [
+      "\\section*{\\colorbox{yellow}{LLM Usage} Statement}",
+      "LLM Usage Statement",
+    ],
+    [
+      "\\section*{\\fontsize{10}{12}\\selectfont LLM \\vspace{1em}Usage\\hspace{2pt} Statement}",
+      "LLM Usage Statement",
+    ],
+    [
+      "\\section*{\\setlength{\\parskip}{0pt}\\addtolength{\\parskip}{1pt}LLM Usage Statement}",
+      "LLM Usage Statement",
+    ],
+  ])("%s → %s", (src, title) => {
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      title,
+    ]);
+  });
+});
+
+describe("outlineOf", () => {
+  it("sections in order with titles collapsed, the first back matter, and the document's end", () => {
+    const src =
+      "\\documentclass{article}\\section{Pre}\n\\begin{document}\n\\section{A  B}\n" +
+      "\\section*{C}\n\\appendix\n\\section{D}\n\\bibliography{r}\n\\end{document}";
+    const o = outlineOf(parseLatex(src));
+    expect(o.sections.map((h) => h.title)).toEqual(["A B", "C", "D"]);
+    expect(o.backMatter).toBe(src.indexOf("\\appendix"));
+    expect(o.end).toBe(src.length - 1);
+    const [a] = o.sections;
+    expect(
+      a?.place.kind === "at" && src.slice(a.place.span.start, a.place.span.end),
+    ).toBe("\\section{A  B}");
+  });
+
+  it("a bibliography environment is back matter too; a fragment has no end; no back matter is null", () => {
+    const src = "\\section{A}\\begin{thebibliography}{1}\\end{thebibliography}";
+    expect(latexReader.outline(src)).toMatchObject({
+      backMatter: src.indexOf("\\begin"),
+      end: null,
+    });
+    expect(latexReader.outline("\\section{A}").backMatter).toBe(null);
+  });
+});
+
+describe("outlineOf — a heading that is never rendered is not in the outline", () => {
+  it.each<[string, string]>([
+    [
+      "a comment environment",
+      "\\begin{comment}\\section{Hidden}\\end{comment}",
+    ],
+    ["a \\newcommand body", "\\newcommand{\\x}{\\section{Hidden}}"],
+    ["a \\def body", "\\def\\y{\\section{Hidden}}"],
+    ["a \\newenvironment body", "\\newenvironment{e}{\\section{Hidden}}{}"],
+  ])("%s", (_, hidden) => {
+    const src = `\\begin{document}${hidden}\\section{Real}\\end{document}`;
+    expect(outlineOf(parseLatex(src)).sections.map((h) => h.title)).toEqual([
+      "Real",
+    ]);
+  });
+});
+
+describe("renderedRuns", () => {
+  it("runs of strings and spaces, each character mapped to its source offset", () => {
+    const src = "A~B \\emph{C D}\n\n E";
+    const runs = renderedRuns(parseLatex(src));
+    expect(runs.map(runText)).toEqual(["A B ", "C D", " E"]);
+    const [first] = runs;
+    expect(first && spanIn(first, 2, 3)).toEqual({ start: 2, end: 3 });
+  });
+
+  it("comments, math, code, keys and the bibliography are not text a reader sees", () => {
+    const src =
+      "x % AISec\n$AISec$ \\cite{AISec} \\label{AISec} \\url{https://AISec.cc}\n" +
+      "\\begin{verbatim}AISec\\end{verbatim}\\begin{thebibliography}{1}\\bibitem{a} AISec\\end{thebibliography}";
+    expect(
+      latexReader
+        .renderedRuns(src)
+        .map(runText)
+        .some((t) => t.includes("AISec")),
+    ).toBe(false);
+  });
+
+  it("a citation's key is hidden, its notes in square brackets are text", () => {
+    const runs = latexReader
+      .renderedRuns("x \\citep[Presented at AISec][p.~3]{zzkey} y")
+      .map(runText);
+    expect(runs.some((t) => t.includes("Presented at AISec"))).toBe(true);
+    expect(runs.some((t) => t.includes("zzkey"))).toBe(false);
+  });
+
+  it("\\href: its URL is hidden, its link text is text", () => {
+    const runs = latexReader
+      .renderedRuns("x \\href{https://example.org/AISec}{the zzlink text} y")
+      .map(runText);
+    expect(runs.some((t) => t.includes("AISec"))).toBe(false);
+    expect(runs.some((t) => t.includes("the zzlink text"))).toBe(true);
+  });
+
+  it("a macro definition's body is read like prose: the rule does not expand macros", () => {
+    const src =
+      "\\newcommand{\\oldvenue}{AISec} \\renewcommand\\b{BISec} \\def\\c{CISec} x";
+    const text = latexReader.renderedRuns(src).map(runText).join("|");
+    expect(
+      ["AISec", "BISec", "CISec", "x"].filter((w) => text.includes(w)),
+    ).toEqual(["AISec", "BISec", "CISec", "x"]);
+  });
+
+  it("the options of other key macros stay hidden: they are settings, not prose", () => {
+    const src = "\\includegraphics[AISec]{f} \\usepackage[AISec]{p}";
+    expect(
+      latexReader
+        .renderedRuns(src)
+        .map(runText)
+        .some((t) => t.includes("AISec")),
+    ).toBe(false);
+  });
+});
+
+describe("inPlace — a node the parser gave no position yields nothing, never offset 0", () => {
+  it("a span is handed to f; an unplaced node gives the empty list", () => {
+    const f = (s: { start: number; end: number }) => [s.start];
+    expect(inPlace({ kind: "at", span: { start: 3, end: 5 } }, f)).toEqual([3]);
+    expect(inPlace({ kind: "unplaced" }, f)).toEqual([]);
+  });
+});
+
+/** A prose piece, readable in an expectation: text as itself, a mark or math in angle brackets. */
+const pieceShape = (x: ProsePiece): string =>
+  x.kind === "text"
+    ? x.segment.text
+    : x.kind === "owner"
+      ? `<${x.owner}@${String(x.span.start)}>`
+      : `<math ${x.tex}>`;
+
+describe("bodyProse — passages a sentence cannot cross, with the marks that say where a claim comes from", () => {
+  it("text, a citation mark, a reference mark and math, in source order; a footnote is its own passage", () => {
+    const src =
+      "\\begin{document}\nA~\\cite{k} B \\ref{s} $x$.\\footnote{F.}\n\n\\section{H}C\\%\n\\end{document}";
+    const at = (s: string) => src.indexOf(s);
+    const shape = bodyProse(parseLatex(src)).map((p) =>
+      p.pieces.map(pieceShape),
+    );
+    expect(shape).toEqual([
+      [
+        "A",
+        " ",
+        `<citation@${String(at("\\cite"))}>`,
+        " ",
+        "B",
+        " ",
+        `<reference@${String(at("\\ref"))}>`,
+        " ",
+        "<math $x$>",
+        ".",
+      ],
+      ["F", "."],
+      ["C", "%"],
+    ]);
+  });
+
+  it("a character macro's character stands at the macro's last source character", () => {
+    const src = "C\\%";
+    const [p] = bodyProse(parseLatex(src));
+    expect(p?.pieces.at(-1)).toEqual({
+      kind: "text",
+      segment: { text: "%", at: 2 },
+    });
+  });
+});
+
+describe("bodyProse — run-in headings and list items", () => {
+  /** The text of each passage of `src`'s body, marks and math left out. */
+  const texts = (src: string): readonly string[] =>
+    bodyProse(parseLatex(src)).map((p) =>
+      p.pieces
+        .map((x) => (x.kind === "text" ? x.segment.text : ""))
+        .join("")
+        .trim(),
+    );
+
+  it("🔴 a run-in heading — a bold, italic or emphasised phrase ending in `.` or `:` that opens a paragraph or an item — is a heading, left out", () => {
+    expect(
+      texts(
+        "\\begin{document}\n\\section{Method}\\label{sec:m}\n\\vspace{2pt}\\textbf{Correctness gate.} Each task carries a check.\n\n\\noindent \\textit{\\textbf{VPNs:}} GPT recommended them.\n\\begin{itemize}\n\\item \\emph{Scale.} It grows.\n\\end{itemize}\n\\end{document}",
+      ),
+    ).toEqual([
+      "Each task carries a check.",
+      "GPT recommended them.",
+      "It grows.",
+    ]);
+  });
+
+  it("🔴 a list item's text is prose, each item its own passage; its label is not — and an \\item outside a list ends a passage", () => {
+    expect(
+      texts(
+        "\\begin{document}\n\\begin{itemize}\n\\item[A:] It grows.\n\\item It holds.\n\\end{itemize}\nAfter \\item the list.\n\\end{document}",
+      ),
+    ).toEqual(["It grows.", "It holds.", "After", "the list."]);
+  });
+
+  it("a run-in heading holding a footnote or a citation is still a heading, left out whole", () => {
+    expect(
+      texts(
+        "\\begin{document}\n\\textbf{Scale\\footnote{F.}.} It grows.\n\n\\textbf{See~\\cite{k}:} It holds.\n\\end{document}",
+      ),
+    ).toEqual(["It grows.", "It holds."]);
+  });
+
+  it("the same markup inside a sentence, or without the closing mark, is prose", () => {
+    expect(
+      texts(
+        "\\begin{document}\nWe \\textbf{do not.} stop.\n\n\\textbf{Bold} opens this one.\n\\end{document}",
+      ),
+    ).toEqual(["We do not. stop.", "Bold opens this one."]);
+  });
+});
+
+describe("includesOf — the files a source pulls in", () => {
+  it("each of \\input, \\include and \\subfile, with the path as written and the macro's span", () => {
+    const src = "a\\input{sections/1-intro}\n\\include{b.tex}\\subfile{c_d}";
+    expect(includesOf(parseLatex(src))).toEqual([
+      {
+        macro: "input",
+        target: "sections/1-intro",
+        span: { start: 1, end: 25 },
+      },
+      { macro: "include", target: "b.tex", span: { start: 26, end: 41 } },
+      { macro: "subfile", target: "c_d", span: { start: 41, end: 54 } },
+    ]);
+  });
+
+  it("\\input without braces (TeX's own form) names the file up to the next space", () => {
+    const targets = (src: string) =>
+      includesOf(parseLatex(src)).map((i) => i.target);
+    expect(targets("\\input sections/a \n")).toEqual(["sections/a"]);
+    // At the end of the source, the name runs to it.
+    expect(targets("\\input sections/a")).toEqual(["sections/a"]);
+  });
+
+  it("an \\input with nothing after it names no file", () => {
+    expect(includesOf(parseLatex("\\input"))).toEqual([]);
+  });
+
+  it("not in a comment, not in a macro definition's body, not an empty argument", () => {
+    const src = "% \\input{old}\n\\newcommand{\\x}{\\input{y}}\\input{}";
+    expect(includesOf(parseLatex(src))).toEqual([]);
+  });
+
+  it("the port answers the same over a source", () => {
+    expect(latexReader.includes("\\input{a}").map((i) => i.target)).toEqual([
+      "a",
+    ]);
+  });
+});
+
+describe("documentBodyOf — the body of a source that is a document of its own", () => {
+  it("from the first to the last node inside the document environment", () => {
+    const src =
+      "\\documentclass{x}\\begin{document}BODY and more\\end{document}";
+    const body = documentBodyOf(parseLatex(src));
+    expect(body && src.slice(body.start, body.end)).toBe("BODY and more");
+    expect(latexReader.documentBody(src)).toEqual(body);
+  });
+
+  it("none without a document environment, or with an empty one", () => {
+    expect(documentBodyOf(parseLatex("just text"))).toBe(null);
+    expect(documentBodyOf(parseLatex("\\begin{document}\\end{document}"))).toBe(
+      null,
+    );
+  });
+});

package/src/adapters/latex/index.ts

@@ -0,0 +1,65 @@
+/**
+ * Reads a paper.tex and answers four questions — checks nothing itself: `documentClassOf` (which
+ * class, with which options, and where), `outlineOf` (the sections in order, where the back matter
+ * starts, where the document ends), `renderedRuns` (the text a reader sees, each character with
+ * its source offset) and `bodyProse` (the body's prose as passages, with its citation and
+ * cross-reference marks). Used by `tex/template`, `tex/required-section`, `tex/venue-leftover`,
+ * `tex/claim-provenance` and `paperlint new`, through the `LatexReader` port (`src/ports/latex.ts`);
+ * `src/cli.ts` wires it.
+ *
+ * ── WHY THE PARSE TREE AND NOT THE `tex/latex` PROJECTION ────────────────────────
+ * The ESLint language's projection (`eslint-rules/latex-language.ts`) blanks the preamble,
+ * `\documentclass`, `\author` and every other macro in its OPAQUE list, because prose rules must
+ * not see markup. These questions are about exactly that markup: the class line, a `\section*`
+ * title, an `\institution{…}` in the author block. So the source is parsed here with unified-latex,
+ * the parser the language already uses.
+ *
+ * ── STATES, NOT NULL ─────────────────────────────────────────────────────────────
+ * A class line is missing, empty or a class; a node the parser gave no position is `unplaced`, not
+ * offset 0; a run of text is a non-empty list of contiguous segments, and a range outside it has
+ * no span (`spanIn` in `src/domain/tex-document.ts`). A tree travels only with its own source
+ * (`ParsedTex`, minted by `parseLatex` alone).
+ */
+import type { LatexReader } from "../../ports/latex.ts";
+import {
+  documentClassOf,
+  parseTemplate,
+  replaceDocumentClass,
+} from "./document-class.ts";
+import { documentBodyOf, includesOf } from "./includes.ts";
+import { outlineOf } from "./outline.ts";
+import { parseLatex } from "./parse.ts";
+import { bodyProse } from "./prose.ts";
+import { renderedRuns } from "./rendered.ts";
+
+export {
+  documentClassOf,
+  parseTemplate,
+  replaceDocumentClass,
+} from "./document-class.ts";
+export {
+  collapse,
+  inPlace,
+  macroPlace,
+  mandatory,
+  optional,
+  placeOf,
+  textOf,
+} from "./nodes.ts";
+export { documentBodyOf, includesOf } from "./includes.ts";
+export { outlineOf } from "./outline.ts";
+export { parseLatex, type ParsedTex } from "./parse.ts";
+export { bodyProse } from "./prose.ts";
+export { renderedRuns } from "./rendered.ts";
+
+/** The `LatexReader` port over unified-latex: each call parses its source once. */
+export const latexReader: LatexReader = {
+  documentClass: (src) => documentClassOf(parseLatex(src)),
+  outline: (src) => outlineOf(parseLatex(src)),
+  renderedRuns: (src) => renderedRuns(parseLatex(src)),
+  bodyProse: (src) => bodyProse(parseLatex(src)),
+  includes: (src) => includesOf(parseLatex(src)),
+  documentBody: (src) => documentBodyOf(parseLatex(src)),
+  template: parseTemplate,
+  withDocumentClass: (src, want) => replaceDocumentClass(parseLatex(src), want),
+};