explico 0.12.0 → 0.13.1

package/dist/compiler/exports/latex/serialize.js

@@ -0,0 +1,606 @@
+import { captionTitle } from "../../../components/float-name.js";
+function labelOf(route, anchor) {
+  return `${route}/${anchor}`;
+}
+const TEXT_ESCAPES = {
+  "\\": "\\textbackslash{}",
+  "{": "\\{",
+  "}": "\\}",
+  $: "\\$",
+  "&": "\\&",
+  "#": "\\#",
+  "^": "\\textasciicircum{}",
+  _: "\\_",
+  "%": "\\%",
+  "~": "\\textasciitilde{}",
+  "<": "\\textless{}",
+  ">": "\\textgreater{}",
+  "|": "\\textbar{}",
+  "\xA0": "~",
+  "\u200B": ""
+};
+const GREEK_WORD = /[\u0370-\u03FF\u1F00-\u1FFF]{2,}/gu;
+function escapeText(text) {
+  return text.replace(/[\\{}$&#^_%~<>| ​]/gu, (char) => TEXT_ESCAPES[char] ?? char).replace(GREEK_WORD, (word) => `\\ExplicoGreekWord{${word}}`);
+}
+function escapeUrl(url) {
+  return url.replace(/[\\{}]/gu, "").replace(/[%#]/gu, (char) => `\\${char}`);
+}
+function texVisibleLength(tex) {
+  return tex.replace(/\\(?:explain|slot)\{[^{}]*\}/gu, "").replace(/\\(?:left|right|[bB]igg?[lr]?|quad|qquad)(?![a-zA-Z])/gu, "").replace(/\\[,;:!]/gu, "").replace(/\\[a-zA-Z]+/gu, "x").replace(/[{}^_\s]/gu, "").length;
+}
+function visibleLength(inlines) {
+  let length = 0;
+  for (const inline of inlines) {
+    if (inline.kind === "text" || inline.kind === "code") length += inline.value.length;
+    else if (inline.kind === "math") length += texVisibleLength(inline.tex);
+    else if (inline.kind === "cite") length += inline.number.length + 2;
+    else if ("children" in inline) length += visibleLength(inline.children);
+  }
+  return length;
+}
+function isMathOnly(inlines) {
+  const content = inlines.filter((inline) => !(inline.kind === "text" && !inline.value.trim()));
+  return content.length > 0 && content.every((inline) => inline.kind === "math");
+}
+function plainText(inlines) {
+  return inlines.map((inline) => {
+    switch (inline.kind) {
+      case "text":
+      case "code":
+        return inline.value;
+      case "math":
+        return inline.tex;
+      case "break":
+        return " ";
+      case "cite":
+        return `[${inline.number}]`;
+      case "memoMark":
+        return inline.label;
+      default:
+        return "children" in inline ? plainText(inline.children) : "";
+    }
+  }).join("");
+}
+function citationKeys(blocks) {
+  const keys = /* @__PURE__ */ new Map();
+  const visitInlines = (inlines) => {
+    for (const inline of inlines) {
+      if (inline.kind === "cite" && inline.sourceId) keys.set(inline.anchor, inline.sourceId);
+      if ("children" in inline) visitInlines(inline.children);
+    }
+  };
+  const visitBlocks = (list) => {
+    for (const block of list) {
+      if ("children" in block && Array.isArray(block.children)) {
+        if (block.kind === "paragraph" || block.kind === "heading") visitInlines(block.children);
+        else visitBlocks(block.children);
+      }
+      if (block.kind === "list") block.items.forEach(visitBlocks);
+      if (block.kind === "examples") block.items.forEach((item) => visitBlocks(item.children));
+      if (block.kind === "table") [...block.head, ...block.body].flat().forEach((cell) => visitInlines(cell.children));
+      if ("caption" in block) visitInlines(block.caption);
+    }
+  };
+  visitBlocks(blocks);
+  return keys;
+}
+function entryKeys(sourceByAnchor) {
+  const anchorsBySource = /* @__PURE__ */ new Map();
+  for (const [anchor, sourceId] of sourceByAnchor) {
+    const anchors = anchorsBySource.get(sourceId) ?? [];
+    anchors.push(anchor);
+    anchorsBySource.set(sourceId, anchors);
+  }
+  const keys = /* @__PURE__ */ new Map();
+  for (const [sourceId, anchors] of anchorsBySource) {
+    for (const anchor of anchors) {
+      keys.set(anchor, anchors.length === 1 ? sourceId : `${sourceId}/${anchor}`);
+    }
+  }
+  return keys;
+}
+function linkExplains(tex, linkTo) {
+  const marker = "\\explain{";
+  let out = "";
+  let index = 0;
+  for (; ; ) {
+    const start = tex.indexOf(marker, index);
+    if (start < 0) return out + tex.slice(index);
+    const keyEnd = tex.indexOf("}", start + marker.length);
+    if (keyEnd < 0 || tex[keyEnd + 1] !== "{") {
+      out += tex.slice(index, start + marker.length);
+      index = start + marker.length;
+      continue;
+    }
+    let depth = 0;
+    let close = keyEnd + 1;
+    for (; close < tex.length; close++) {
+      const char = tex[close];
+      if (char === "\\") close++;
+      else if (char === "{") depth++;
+      else if (char === "}" && --depth === 0) break;
+    }
+    if (close >= tex.length) return out + tex.slice(index);
+    const key = tex.slice(start + marker.length, keyEnd);
+    const target = linkTo(key);
+    const inner = tex.slice(keyEnd + 2, close);
+    const body = target ? inner : linkExplains(inner, linkTo);
+    out += tex.slice(index, start);
+    out += target ? `\\ExplicoNotation{${target}}{${body}}` : `\\explain{${key}}{${body}}`;
+    index = close + 1;
+  }
+}
+class ChapterWriter {
+  constructor(context) {
+    this.context = context;
+    this.route = context.page.route;
+    this.citationKeys = entryKeys(citationKeys(context.page.blocks));
+  }
+  context;
+  route;
+  citationKeys;
+  /** Above zero inside a moving argument (a heading, a caption, a title) or a link: no link goes there. */
+  unlinked = 0;
+  /** A reference-list entry's citation key in this document, by its anchor. */
+  citeKey(anchor) {
+    const key = this.citationKeys.get(anchor) ?? anchor;
+    return this.context.inBook ? `${this.route}/${key}` : key;
+  }
+  label(anchor) {
+    return labelOf(this.route, anchor);
+  }
+  /** Renders `write` with links to notation off: a link cannot nest, or sit in a moving argument. */
+  unlinkedWhile(write) {
+    this.unlinked++;
+    try {
+      return write();
+    } finally {
+      this.unlinked--;
+    }
+  }
+  /** Inline content with no notation links inside it. */
+  plain(inlines) {
+    return this.unlinkedWhile(() => this.inlines(inlines));
+  }
+  /** A formula's TeX, with its notation markers linked to the appendix where the document has the entry. */
+  math(tex) {
+    const targets = this.context.notationTargets;
+    if (this.unlinked > 0 || !targets || targets.size === 0) return tex;
+    return linkExplains(tex, (key) => targets.has(key) ? labelOf("notation", key) : void 0);
+  }
+  inDocument(target) {
+    return this.context.documentRoutes.has(target.route);
+  }
+  canonicalUrl(target) {
+    const base = this.context.canonicalBaseUrl;
+    if (!base) return void 0;
+    const path = target.route ? `${target.route}/` : "";
+    return `${base}${path}${target.anchor ? `#${target.anchor}` : ""}`;
+  }
+  /** A cross-reference: LaTeX's number inside the document, the website's outside it. */
+  reference(refKind, target, children) {
+    const text = plainText(children);
+    if (this.inDocument(target) && target.anchor) {
+      const label = labelOf(target.route, target.anchor);
+      if (refKind === "equation" && /^\(\s*[\d.]+\s*\)$/u.test(text.trim())) {
+        return `\\ExplicoEqRef{${label}}`;
+      }
+      const number = /\d+(?:\.\d+)*/u.exec(text);
+      if (number && ["equation", "figure", "table", "diagram", "section", "example", "check"].includes(refKind)) {
+        const before = text.slice(0, number.index);
+        const after = text.slice(number.index + number[0].length);
+        return `\\ExplicoRef{${label}}{${escapeText(before)}}{${escapeText(after)}}`;
+      }
+      return `\\hyperref[${label}]{${this.plain(children)}}`;
+    }
+    const url = this.canonicalUrl(target);
+    return url ? `\\href{${escapeUrl(url)}}{${this.plain(children)}}` : this.inlines(children);
+  }
+  inline(inline) {
+    switch (inline.kind) {
+      case "text":
+        return escapeText(inline.value);
+      case "emphasis":
+        return `\\emph{${this.inlines(inline.children)}}`;
+      case "strong":
+        return `\\textbf{${this.inlines(inline.children)}}`;
+      case "superscript":
+        return `\\textsuperscript{${this.inlines(inline.children)}}`;
+      case "subscript":
+        return `\\textsubscript{${this.inlines(inline.children)}}`;
+      case "code":
+        return `\\texttt{${escapeText(inline.value)}}`;
+      case "math":
+        return `$${this.math(inline.tex)}$`;
+      case "break":
+        return "\\newline ";
+      case "link":
+        return `\\href{${escapeUrl(inline.href)}}{${this.plain(inline.children)}}`;
+      case "ref":
+        return this.reference(inline.refKind, inline.target, inline.children);
+      case "term":
+        return `\\ExplicoTerm{${inline.key}}{${this.inlines(inline.children)}}`;
+      case "cite":
+        return inline.sourceId ? `\\cite{${this.citeKey(inline.anchor)}}` : `[${escapeText(inline.number)}]`;
+      case "memoMark":
+        return `\\ExplicoMemoMark{${this.label(inline.anchor)}}`;
+      case "noteMark":
+        return `\\ExplicoNoteMark{${this.label(inline.anchor)}}{${this.plain(inline.children)}}`;
+    }
+  }
+  inlines(inlines) {
+    return inlines.map((inline) => this.inline(inline)).join("");
+  }
+  segments(segments) {
+    return segments.map((segment) => segment.type === "math" ? `$${this.math(segment.latex)}$` : escapeText(segment.value)).join("");
+  }
+  /** A float's caption: its short caption for the lists, bold before the long one. */
+  caption(block, extra = []) {
+    const short = block.short?.trim();
+    const long = [this.plain(block.caption), this.plain(extra)].filter(Boolean).join(" ");
+    const title = short ? `\\ExplicoCaptionTitle{${escapeText(captionTitle(short))}} ` : "";
+    const list = short ? `[${escapeText(short)}]` : "";
+    return `\\caption${list}{${title}${long}}\\label{${this.label(block.anchor)}}`;
+  }
+  /**
+   * A float. Inside a box (a memo, a worked example) a float cannot float, so
+   * it is set where it stands (`ExplicoHere`, explico.cls) and keeps its number.
+   */
+  float(kind, inPlace, content, caption, captionFirst = false) {
+    const parts = captionFirst ? [caption, content] : [content, caption];
+    if (inPlace) return [`\\begin{ExplicoHere}{${kind}}`, ...parts, "\\end{ExplicoHere}"].join("\n");
+    return [`\\begin{${kind}}[htbp]`, "\\centering", ...parts, `\\end{${kind}}`].join("\n");
+  }
+  picture(anchor, picture, alt) {
+    if (picture.kind === "diagram") return diagramTikz(picture.geometry, this);
+    const file = this.context.pictures.get(anchor);
+    if (file) {
+      const text = escapeText(alt || "Figure");
+      return `\\includegraphics[alt={${text}},max width=\\linewidth,max height=0.6\\textheight]{${file}}`;
+    }
+    return `\\fbox{\\parbox{0.9\\linewidth}{\\centering\\small\\itshape ${escapeText(
+      alt || "Interactive figure"
+    )}: see the interactive version on the course website.}}`;
+  }
+  table(block, inBox = false) {
+    const rows = [...block.head, ...block.body];
+    const columns = Math.max(0, ...rows.map((row2) => row2.reduce((sum, cell) => sum + cell.colspan, 0)));
+    if (columns === 0) return "";
+    const cellAt = (row2, column) => {
+      let position = 0;
+      for (const cell of row2) {
+        if (position === column && cell.colspan === 1) return cell;
+        position += cell.colspan;
+      }
+      return void 0;
+    };
+    const widths = Array.from(
+      { length: columns },
+      (_, column) => Math.max(0, ...rows.map((row2) => visibleLength(cellAt(row2, column)?.children ?? [])))
+    );
+    const prose = Array.from(
+      { length: columns },
+      (_, column) => block.body.some((row2) => {
+        const cell = cellAt(row2, column);
+        return !!cell && !isMathOnly(cell.children) && /[a-z]{3}/iu.test(plainText(cell.children));
+      })
+    );
+    const total = widths.reduce((sum, width) => sum + width + 2, 0);
+    const wraps = total > 75 && prose.some((isProse, column) => isProse && widths[column] > 18);
+    const alignOf = (column) => {
+      if (wraps && prose[column] && widths[column] > 18) return ">{\\raggedright\\arraybackslash}X";
+      const align = (block.body[0] && cellAt(block.body[0], column)?.align) ?? cellAt(block.head[0] ?? [], column)?.align;
+      return align === "right" ? "r" : align === "center" ? "c" : "l";
+    };
+    const spec = Array.from({ length: columns }, (_, column) => alignOf(column)).join("");
+    const dense = columns >= 8;
+    const row = (cells) => `${cells.map((cell) => {
+      const content = this.inlines(cell.children);
+      return cell.colspan > 1 ? `\\multicolumn{${cell.colspan}}{l}{${content}}` : content;
+    }).join(" & ")} \\\\`;
+    const body = [
+      "\\toprule",
+      ...block.head.map(row),
+      ...block.head.length > 0 ? ["\\midrule"] : [],
+      ...block.body.map(row),
+      "\\bottomrule"
+    ];
+    const tabular = wraps ? ["\\small", `\\begin{tabularx}{\\linewidth}{@{}${spec}@{}}`, ...body, "\\end{tabularx}"].join("\n") : [
+      dense ? "\\footnotesize\\setlength{\\tabcolsep}{4pt}" : "\\small",
+      "\\begin{adjustbox}{max width=\\linewidth}",
+      `\\begin{tabular}{@{}${spec}@{}}`,
+      ...body,
+      "\\end{tabular}",
+      "\\end{adjustbox}"
+    ].join("\n");
+    if (!block.number) return `\\begin{center}
+${tabular}
+\\end{center}`;
+    return this.float("table", inBox, tabular, this.caption(block), true);
+  }
+  /** A choice's label, its math typeset like the prompt's. */
+  optionLabel(option) {
+    return option.labelSegments ? this.segments(option.labelSegments) : escapeText(option.label);
+  }
+  check(block) {
+    const items = this.context.checkItems.get(block.assessmentId) ?? [];
+    const questions = items.map((item) => {
+      const options = item.type === "single-choice" && item.options && item.options.length > 0 ? [
+        "\\begin{enumerate}[label=(\\alph*)]",
+        ...item.options.map((option) => `\\item ${this.optionLabel(option)}`),
+        "\\end{enumerate}"
+      ].join("\n") : "";
+      return `\\item ${this.segments(item.promptSegments)}${options ? `
+${options}` : ""}`;
+    });
+    return [
+      `\\begin{ExplicoCheck}{${this.plain(block.title)}}\\label{${this.label(block.anchor)}}`,
+      ...questions.length > 0 ? ["\\begin{enumerate}", ...questions, "\\end{enumerate}"] : [],
+      `\\ExplicoCheckAnswerNote{${this.label("answers")}}`,
+      "\\end{ExplicoCheck}"
+    ].join("\n");
+  }
+  /** The chapter's answer key: every check's answers and explanations, in order. */
+  answers(checks) {
+    if (checks.length === 0) return "";
+    const parts = [`\\section*{Answers to the knowledge checks}\\hypertarget{${this.label("answers")}}{}`];
+    for (const check of checks) {
+      const items = this.context.checkItems.get(check.assessmentId) ?? [];
+      parts.push(
+        `\\paragraph*{\\ExplicoRef{${this.label(check.anchor)}}{Knowledge check~}{}: ${this.plain(check.title)}}`
+      );
+      parts.push("\\begin{enumerate}");
+      for (const item of items) {
+        let answer = "";
+        if (item.type === "single-choice" && item.options) {
+          const index = item.options.findIndex((option) => option.id === item.correctOptionId);
+          if (index !== -1) {
+            answer = `\\textbf{(${String.fromCharCode(97 + index)})} ${this.optionLabel(item.options[index])}. `;
+          }
+        } else if (item.type === "numeric" && item.answer) {
+          answer = `\\textbf{$${item.answer.value}$} (accepted within $\\pm${item.answer.tolerance}$). `;
+        }
+        parts.push(`\\item ${answer}${this.segments(item.explanationSegments)}`);
+      }
+      parts.push("\\end{enumerate}");
+    }
+    return parts.join("\n");
+  }
+  block(block, inBox = false) {
+    switch (block.kind) {
+      case "heading": {
+        const text = this.plain(block.children);
+        const label = block.anchor ? `\\label{${this.label(block.anchor)}}` : "";
+        if (inBox) return `\\par\\smallskip\\noindent\\textbf{${text}}${label}\\par`;
+        const command = ["section", "subsection", "subsubsection", "paragraph", "subparagraph"][Math.min(Math.max(block.level - 2, 0), 4)] ?? "paragraph";
+        const star = block.number ? "" : "*";
+        return `\\${command}${star}{${text}}${label}`;
+      }
+      case "paragraph":
+        return this.inlines(block.children);
+      case "list": {
+        const environment = block.ordered ? "enumerate" : "itemize";
+        const start = block.ordered && block.start && block.start !== 1 ? `\\setcounter{enumi}{${block.start - 1}}
+` : "";
+        const items = block.items.map((item) => `\\item ${this.blocks(item, inBox)}`);
+        return `\\begin{${environment}}
+${start}${items.join("\n")}
+\\end{${environment}}`;
+      }
+      case "equation":
+        return `\\begin{equation}\\label{${this.label(block.anchor)}}
+${this.math(block.tex)}
+\\end{equation}`;
+      case "displayMath":
+        return `\\[
+${this.math(block.tex)}
+\\]`;
+      case "figure":
+        return this.float(
+          "figure",
+          inBox,
+          this.picture(
+            block.anchor,
+            block.picture,
+            block.alt ?? [block.short && captionTitle(block.short), plainText(block.caption)].filter(Boolean).join(" ")
+          ),
+          this.caption(block, block.live)
+        );
+      case "diagram":
+        return this.float(
+          "diagram",
+          inBox,
+          this.unlinkedWhile(() => diagramTikz(block.geometry, this)),
+          this.caption(block)
+        );
+      case "table":
+        return this.table(block, inBox);
+      case "memo":
+        return [
+          `\\begin{ExplicoMemo}{${this.plain(block.title)}}\\label{${this.label(block.anchor)}}`,
+          this.blocks(block.children, true),
+          "\\end{ExplicoMemo}"
+        ].join("\n");
+      case "note":
+        return [
+          `\\begin{ExplicoNote}{${this.label(block.anchor)}}{${escapeText(block.title)}}`,
+          this.blocks(block.children, true),
+          "\\end{ExplicoNote}"
+        ].join("\n");
+      case "aside":
+        return [
+          `\\begin{ExplicoAside}{${block.variant}}{${this.plain(block.title)}}`,
+          this.blocks(block.children, true),
+          "\\end{ExplicoAside}"
+        ].join("\n");
+      case "fold":
+        return [
+          ...block.title ? [`\\paragraph*{${this.plain(block.title)}}`] : [],
+          this.blocks(block.children, inBox)
+        ].join("\n");
+      case "examples":
+        return [
+          `\\begin{ExplicoExamples}{${this.plain(block.title)}}\\label{${this.label(block.anchor)}}`,
+          ...block.items.flatMap((item) => [
+            `\\ExplicoExample{${this.plain(item.title)}}`,
+            this.blocks(item.children, true)
+          ]),
+          "\\end{ExplicoExamples}"
+        ].join("\n");
+      case "check":
+        return this.check(block);
+      case "quote":
+        return `\\begin{quote}
+${this.blocks(block.children, inBox)}
+\\end{quote}`;
+      case "image": {
+        const file = this.context.pictures.get(block.src);
+        return file ? `\\begin{center}\\includegraphics[max width=\\linewidth]{${file}}\\end{center}` : "";
+      }
+      case "code":
+        return `\\begin{verbatim}
+${block.value}
+\\end{verbatim}`;
+      case "rule":
+        return "\\par\\noindent\\rule{\\linewidth}{0.4pt}\\par";
+      case "references":
+        return [
+          `\\begin{ExplicoReferences}{${block.items.length}}`,
+          ...block.items.map(
+            (item) => `\\bibitem{${this.citeKey(item.anchor)}} ${this.plain(item.children)}`
+          ),
+          "\\end{ExplicoReferences}"
+        ].join("\n");
+    }
+  }
+  blocks(blocks, inBox = false) {
+    return blocks.map((block) => this.block(block, inBox)).filter((text) => text.trim().length > 0).join("\n\n");
+  }
+  notation(entries, remarks) {
+    if (entries.length === 0) return "";
+    const items = entries.map((entry) => {
+      const symbol = entry.symbolTex ? `$${entry.symbolTex}$` : "";
+      const parts = [
+        `\\textbf{${this.inlines(entry.label)}}.`,
+        this.inlines(entry.summary),
+        ...entry.units ? [`\\emph{Units:} ${this.inlines(entry.units)}.`] : [],
+        ...entry.formulaTex ? [`\\[${entry.formulaTex}\\]`] : []
+      ];
+      return `\\item[${symbol}]\\hypertarget{${this.label(entry.anchor)}}{}${parts.join(" ")}`;
+    });
+    return [
+      "\\section*{Notation}",
+      ...remarks.map((remark) => `\\noindent\\emph{${this.inlines(remark)}}\\par\\medskip`),
+      "\\begin{description}",
+      ...items,
+      "\\end{description}"
+    ].join("\n");
+  }
+}
+function diagramTikz(geometry, writer) {
+  if (geometry.nodes.length === 0) return "";
+  const scale = 0.75 * Math.min(1, 450 / Math.max(1, geometry.width * 0.75));
+  const pt = (value) => `${(value * scale).toFixed(1)}pt`;
+  const point = (x, y) => `(${pt(x)},${pt(-y)})`;
+  const nodes = geometry.nodes.map((node) => {
+    const text = node.text ? writer.inlines([{ kind: "text", value: node.text }]) : "";
+    const math = node.tex ? `$${node.tex}$` : "";
+    const content = [text, math].filter(Boolean).join("\\\\ ");
+    const textWidth = Math.max(10, node.width * scale - 8).toFixed(1);
+    return `\\node[explico diagram node,minimum width=${pt(node.width)},minimum height=${pt(node.height)},text width=${textWidth}pt] at ${point(node.x + node.width / 2, node.y + node.height / 2)} {${content}};`;
+  });
+  const edges = geometry.edges.map(
+    (edge) => `\\draw[explico diagram edge] ${edge.map(([x, y]) => point(x, y)).join(" -- ")};`
+  );
+  return ["\\begin{tikzpicture}", ...edges, ...nodes, "\\end{tikzpicture}"].join("\n");
+}
+function serializeChapter(context) {
+  const writer = new ChapterWriter(context);
+  const { page } = context;
+  const checks = [];
+  const collect = (blocks) => {
+    for (const block of blocks) {
+      if (block.kind === "check") checks.push(block);
+      if ("children" in block && Array.isArray(block.children) && block.kind !== "paragraph" && block.kind !== "heading") {
+        collect(block.children);
+      }
+    }
+  };
+  collect(page.blocks);
+  const source = context.source;
+  const sourceLine = !source ? [] : context.inBook ? source.url ? [`\\ExplicoInteractive{${escapeUrl(source.url)}}`] : [] : [
+    `\\ExplicoSource{${escapeText(source.course)}}{${escapeText(source.version ?? "")}}{${source.url ? escapeUrl(source.url) : ""}}`
+  ];
+  return [
+    `\\chapter{${escapeText(page.title)}}\\label{${labelOf(page.route, "_top")}}`,
+    "\\ExplicoApplyOffsets",
+    ...sourceLine,
+    writer.blocks(page.blocks),
+    ...context.inBook ? [] : [writer.notation(page.notation, page.notationRemarks)],
+    writer.answers(checks),
+    ""
+  ].filter((part) => part !== void 0).join("\n\n");
+}
+function serializePartOpener(context, part) {
+  const writer = new ChapterWriter({ ...context, inBook: true });
+  return [
+    `\\ExplicoPart{${part.ordinal}}{${escapeText(part.label)}}\\label{${labelOf(context.page.route, "_top")}}`,
+    writer.blocks(context.page.blocks),
+    ""
+  ].join("\n\n");
+}
+function serializeNotationAppendix(entries, context) {
+  if (entries.length === 0) return "";
+  const writers = /* @__PURE__ */ new Map();
+  const writerFor = (page) => {
+    let writer = writers.get(page.route);
+    if (!writer) {
+      writer = new ChapterWriter({ ...context, page, inBook: true });
+      writers.set(page.route, writer);
+    }
+    return writer;
+  };
+  const targets = context.notationTargets;
+  const formula = (key, tex) => targets ? linkExplains(tex, (named) => named !== key && targets.has(named) ? labelOf("notation", named) : void 0) : tex;
+  const items = entries.map(({ entry, page, chapter }) => {
+    const writer = writerFor(page);
+    const parts = [
+      `\\textbf{${writer.inlines(entry.label)}}.`,
+      writer.inlines(entry.summary),
+      ...entry.units ? [`\\emph{Units:} ${writer.inlines(entry.units)}.`] : [],
+      ...chapter ? [`\\emph{In Chapter~${chapter} only.}`] : [],
+      ...entry.formulaTex ? [`\\[${formula(entry.key, entry.formulaTex)}\\]`] : []
+    ];
+    const symbol = entry.symbolTex ? `$${entry.symbolTex}$` : "";
+    return `\\item[{${symbol}}]\\hypertarget{${labelOf("notation", entry.key)}}{}${parts.join(" ")}`;
+  });
+  return [
+    "\\chapter{Notation}\\label{appendix/notation}",
+    "The symbols of this book, in the order they first appear.",
+    "\\begin{description}",
+    ...items,
+    "\\end{description}",
+    ""
+  ].join("\n");
+}
+function serializeAbbreviationAppendix(abbreviations) {
+  if (abbreviations.length === 0) return "";
+  return [
+    "\\chapter{Abbreviations}\\label{appendix/abbreviations}",
+    "\\begin{description}",
+    ...[...abbreviations].sort((a, b) => a.abbr.localeCompare(b.abbr)).map((entry) => `\\item[{${escapeText(entry.abbr)}}] ${escapeText(entry.expansion)}`),
+    "\\end{description}",
+    ""
+  ].join("\n");
+}
+export {
+  diagramTikz,
+  escapeText,
+  labelOf,
+  linkExplains,
+  serializeAbbreviationAppendix,
+  serializeChapter,
+  serializeNotationAppendix,
+  serializePartOpener
+};

package/dist/compiler/exports/latex-export.d.ts

@@ -0,0 +1,44 @@
+import { Manifest } from '../manifest.js';
+import { ExportLogger, PreparedChapters } from './export-chapters.js';
+import '../../curriculum/validation.js';
+import '../../reference/consistency.js';
+import '../../course-config-rRtME5UV.js';
+import '../../rules/catalog.js';
+import '../../rules/course-rules.js';
+import '../collections.js';
+import '../../reference/types.js';
+import '../../reference/gate-retired-keys.js';
+import '../../reference/lint-ignore.js';
+import '../../reference/equations-validate.js';
+import '../../reference/tables-validate.js';
+import '../../reference/keyed-float-validate.js';
+import '../../reference/figures-validate.js';
+import '../../reference/diagrams-validate.js';
+import '../../reference/examples-validate.js';
+import '../../reference/folds-validate.js';
+import '../../reference/knowledge-checks-validate.js';
+import '../../reference/raw-floats-validate.js';
+import '../../reference/lab-katex-validate.js';
+import '../../reference/gate-math.js';
+import '../../reference/mixed-content.js';
+import '../../reference/gloss.js';
+import '../../rules/waivers.js';
+import '../knowledge-version.js';
+import '../lesson-derivation.js';
+import './static-tree.js';
+import './html-tree.js';
+import 'parse5';
+import './latex/capture.js';
+
+/**
+ * Write each chapter's, each part's and the course's LaTeX source zip and PDF
+ * under `downloads/`, from the chapters `prepareChapters` read and drew (read
+ * here when not given).
+ */
+declare function writeLatexExports(directory: URL, manifest: Manifest, options?: {
+    readonly logger?: ExportLogger;
+    readonly projectRoot?: string;
+    readonly prepared?: PreparedChapters;
+}): Promise<void>;
+
+export { ExportLogger, writeLatexExports };