docrev 0.8.1 → 0.8.5

package/lib/{crossref.js → crossref.ts}

@@ -10,26 +10,81 @@
 import * as fs from 'fs';
 import * as path from 'path';
 import YAML from 'yaml';
+import type {
+  RefNumber,
+  HardcodedRef,
+  DynamicRef,
+  FigureInfo,
+  Registry,
+  RefStatus,
+  ConversionResult,
+} from './types.js';
+
+// =============================================================================
+// Constants
+// =============================================================================
+
+/** Characters of context to check before a reference for deduplication */
+const REF_CONTEXT_WINDOW = 100;
+
+/** Minimum word length for similarity calculations */
+const MIN_WORD_LENGTH = 2;
+
+// =============================================================================
+// Type Definitions (Internal)
+// =============================================================================
+
+/**
+ * Reference info (internal use in registry building)
+ */
+interface RefInfo {
+  label: string;
+  num: number;
+  isSupp: boolean;
+  file: string;
+}
+
+/**
+ * Parsed reference number components
+ */
+interface ParsedRefNumber {
+  isSupp: boolean;
+  num: number;
+  suffix: string | null;
+}
+
+/**
+ * Detected reference with parsed numbers
+ */
+interface DetectedRef {
+  type: 'fig' | 'tbl' | 'eq';
+  match: string;
+  numbers: ParsedRefNumber[];
+  position: number;
+}
+
+// =============================================================================
+// Internal Helpers
+// =============================================================================
 
 /**
  * Discover section files from a directory by reading config files
  * Only returns files explicitly defined in rev.yaml or sections.yaml
  * Returns empty array if no config found (caller should handle this)
- *
- * @param {string} directory
- * @returns {string[]} Ordered list of section filenames, or empty if no config
  */
-function discoverSectionFiles(directory) {
+function discoverSectionFiles(directory: string): string[] {
   // Try rev.yaml first
   const revYamlPath = path.join(directory, 'rev.yaml');
   if (fs.existsSync(revYamlPath)) {
     try {
       const config = YAML.parse(fs.readFileSync(revYamlPath, 'utf-8'));
       if (config.sections && Array.isArray(config.sections) && config.sections.length > 0) {
-        return config.sections.filter(f => fs.existsSync(path.join(directory, f)));
+        return config.sections.filter((f: string) => fs.existsSync(path.join(directory, f)));
+      }
+    } catch (e) {
+      if (process.env.DEBUG) {
+        console.warn('crossref: YAML parse error in rev.yaml:', (e as Error).message);
       }
-    } catch {
-      // Ignore yaml errors, try next option
     }
   }
 
@@ -40,12 +95,14 @@ function discoverSectionFiles(directory) {
       const config = YAML.parse(fs.readFileSync(sectionsPath, 'utf-8'));
       if (config.sections) {
         const sectionOrder = Object.entries(config.sections)
-          .sort((a, b) => (a[1].order ?? 999) - (b[1].order ?? 999))
+          .sort((a, b) => ((a[1] as any).order ?? 999) - ((b[1] as any).order ?? 999))
           .map(([file]) => file);
-        return sectionOrder.filter(f => fs.existsSync(path.join(directory, f)));
+        return sectionOrder.filter((f) => fs.existsSync(path.join(directory, f)));
+      }
+    } catch (e) {
+      if (process.env.DEBUG) {
+        console.warn('crossref: YAML parse error in sections.yaml:', (e as Error).message);
       }
-    } catch {
-      // Ignore yaml errors
     }
   }
 
@@ -54,6 +111,10 @@ function discoverSectionFiles(directory) {
   return [];
 }
 
+// =============================================================================
+// Detection Patterns
+// =============================================================================
+
 /**
  * Patterns for detecting hardcoded references
  * Matches complex patterns including:
@@ -64,7 +125,7 @@ function discoverSectionFiles(directory) {
  *
  * Uses a simpler base pattern and parses the full match for lists
  */
-const DETECTION_PATTERNS = {
+const DETECTION_PATTERNS: Record<string, RegExp> = {
   // Captures the full reference including lists with "and"
   // Group 1: type prefix (Figure, Fig., etc.)
   // Group 2: reference list (parsed by parseReferenceList())
@@ -103,12 +164,17 @@ const ANCHOR_PATTERN = /\{#(fig|tbl|eq):([^}]+)\}/gi;
  */
 const REF_PATTERN = /@(fig|tbl|eq):([a-zA-Z0-9_-]+)/gi;
 
+// =============================================================================
+// Public API
+// =============================================================================
+
 /**
  * Normalize a reference type to standard form
- * @param {string} typeStr - e.g., "Figure", "Fig.", "Figs", "table"
- * @returns {string} - "fig", "tbl", or "eq"
  */
-export function normalizeType(typeStr) {
+export function normalizeType(typeStr: string): 'fig' | 'tbl' | 'eq' | string {
+  if (typeof typeStr !== 'string') {
+    throw new TypeError(`typeStr must be a string, got ${typeof typeStr}`);
+  }
   const lower = typeStr.toLowerCase().replace(/\.$/, '');
   if (lower.startsWith('fig')) return 'fig';
   if (lower.startsWith('tab')) return 'tbl';
@@ -118,17 +184,16 @@ export function normalizeType(typeStr) {
 
 /**
  * Parse a reference number, handling supplementary (S1, S2) and letter suffixes (1a, 1b)
- * @param {string} numStr - e.g., "1", "S1", "S2", "1a", "S1b"
- * @param {string} [suffix] - optional letter suffix already extracted
- * @returns {{isSupp: boolean, num: number, suffix: string|null}}
  */
-export function parseRefNumber(numStr, suffix = null) {
-  if (!numStr) return { isSupp: false, num: 0, suffix };
+export function parseRefNumber(numStr: string, suffix: string | null = null): ParsedRefNumber {
+  if (!numStr || typeof numStr !== 'string') {
+    return { isSupp: false, num: 0, suffix: suffix || null };
+  }
   const isSupp = numStr.toUpperCase().startsWith('S');
   const numPart = isSupp ? numStr.slice(1) : numStr;
   // Extract suffix if embedded in numStr (e.g., "1a")
   const match = numPart.match(/^(\d+)([a-z])?$/i);
-  const num = match ? parseInt(match[1], 10) : parseInt(numPart, 10);
+  const num = match && match[1] ? parseInt(match[1], 10) : parseInt(numPart, 10);
   const extractedSuffix = suffix || (match && match[2]) || null;
   return { isSupp, num, suffix: extractedSuffix ? extractedSuffix.toLowerCase() : null };
 }
@@ -136,24 +201,21 @@ export function parseRefNumber(numStr, suffix = null) {
 /**
  * Parse a reference list string like "1, 2, and 3" or "1a-c" or "1a-3b"
  * Returns an array of {num, isSupp, suffix} objects
- *
- * @param {string} listStr - e.g., "1, 2, and 3", "1a-c", "1a-3b", "1a, b, c"
- * @returns {Array<{num: number, isSupp: boolean, suffix: string|null}>}
  */
-export function parseReferenceList(listStr) {
-  const results = [];
-  if (!listStr) return results;
+export function parseReferenceList(listStr: string): ParsedRefNumber[] {
+  const results: ParsedRefNumber[] = [];
+  if (!listStr || typeof listStr !== 'string') return results;
 
   // Normalize: replace "and" with comma, normalize dashes
   let normalized = listStr
     .replace(/\s+and\s+/gi, ', ')
-    .replace(/[–—]/g, '-')   // en-dash, em-dash → hyphen
-    .replace(/&/g, ', ');    // & → comma
+    .replace(/[–—]/g, '-') // en-dash, em-dash → hyphen
+    .replace(/&/g, ', '); // & → comma
 
   // Split by comma (but not by dash, which indicates ranges)
-  const parts = normalized.split(/\s*,\s*/).filter(p => p.trim());
+  const parts = normalized.split(/\s*,\s*/).filter((p) => p.trim());
 
-  let lastFullRef = null; // Track the last full reference for implicit prefixes
+  let lastFullRef: { num: number; isSupp: boolean } | null = null; // Track the last full reference for implicit prefixes
 
   for (const part of parts) {
     const trimmed = part.trim();
@@ -161,7 +223,9 @@ export function parseReferenceList(listStr) {
 
     // Check if this is a range (contains -)
     if (trimmed.includes('-')) {
-      const [start, end] = trimmed.split('-').map(s => s.trim());
+      const parts = trimmed.split('-').map((s) => s.trim());
+      const start = parts[0] || '';
+      const end = parts[1] || '';
 
       // Check if end is just a letter (e.g., "1a-c" where end is "c")
       const endIsLetterOnly = /^[a-z]$/i.test(end);
@@ -187,22 +251,23 @@ export function parseReferenceList(listStr) {
         );
 
         for (let n = startRef.num; n <= endRef.num; n++) {
-          const suffixStart = (n === startRef.num) ? startRef.suffix.charCodeAt(0) : 'a'.charCodeAt(0);
-          const suffixEnd = (n === endRef.num) ? endRef.suffix.charCodeAt(0) : maxSuffix;
+          const suffixStart =
+            n === startRef.num ? startRef.suffix.charCodeAt(0) : 'a'.charCodeAt(0);
+          const suffixEnd = n === endRef.num ? endRef.suffix.charCodeAt(0) : maxSuffix;
 
           for (let s = suffixStart; s <= suffixEnd; s++) {
             results.push({
               num: n,
               isSupp: startRef.isSupp,
-              suffix: String.fromCharCode(s)
+              suffix: String.fromCharCode(s),
             });
           }
         }
         lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
       } else if (startRef.suffix || endRef.suffix) {
         // Suffix range on same number: "1a-c"
-        const num = startRef.num || (lastFullRef ? lastFullRef.num : 1);
-        const isSupp = startRef.isSupp || (lastFullRef ? lastFullRef.isSupp : false);
+        const num: number = startRef.num !== 0 ? startRef.num : (lastFullRef ? lastFullRef.num : 1);
+        const isSupp: boolean = startRef.isSupp ? startRef.isSupp : (lastFullRef ? lastFullRef.isSupp : false);
         const startCode = (startRef.suffix || 'a').charCodeAt(0);
         const endCode = (endRef.suffix || 'a').charCodeAt(0);
 
@@ -210,7 +275,7 @@ export function parseReferenceList(listStr) {
           results.push({
             num,
             isSupp,
-            suffix: String.fromCharCode(code)
+            suffix: String.fromCharCode(code),
           });
         }
         lastFullRef = { num, isSupp };
@@ -220,7 +285,7 @@ export function parseReferenceList(listStr) {
           results.push({
             num: n,
             isSupp: startRef.isSupp,
-            suffix: null
+            suffix: null,
           });
         }
         lastFullRef = { num: endRef.num, isSupp: startRef.isSupp };
@@ -233,7 +298,7 @@ export function parseReferenceList(listStr) {
         results.push({
           num: lastFullRef.num,
           isSupp: lastFullRef.isSupp,
-          suffix: trimmed.toLowerCase()
+          suffix: trimmed.toLowerCase(),
         });
       } else {
         // Full reference: "1", "1a", "S1", "S1a"
@@ -254,22 +319,15 @@ export function parseReferenceList(listStr) {
  * IMPORTANT: This function requires either explicit sections or a rev.yaml/sections.yaml config.
  * It will NOT guess by scanning all .md files, as this leads to incorrect numbering
  * when temporary files (paper_clean.md, etc.) exist in the directory.
- *
- * @param {string} directory - Directory containing .md files
- * @param {string[]} [sections] - Array of section filenames to scan (recommended).
- *   If not provided, reads from rev.yaml or sections.yaml.
- *   Returns empty registry if no sections can be determined.
- * @returns {{
- *   figures: Map<string, {label: string, num: number, isSupp: boolean, file: string}>,
- *   tables: Map<string, {label: string, num: number, isSupp: boolean, file: string}>,
- *   equations: Map<string, {label: string, num: number, file: string}>,
- *   byNumber: {fig: Map<string, string>, tbl: Map<string, string>, eq: Map<string, string>}
- * }}
  */
-export function buildRegistry(directory, sections) {
-  const figures = new Map();
-  const tables = new Map();
-  const equations = new Map();
+export function buildRegistry(directory: string, sections?: string[]): Registry {
+  if (typeof directory !== 'string') {
+    throw new TypeError(`directory must be a string, got ${typeof directory}`);
+  }
+
+  const figures = new Map<string, FigureInfo>();
+  const tables = new Map<string, FigureInfo>();
+  const equations = new Map<string, FigureInfo>();
 
   // Counters for numbering (separate for main and supplementary)
   let figNum = 0;
@@ -278,11 +336,11 @@ export function buildRegistry(directory, sections) {
   let tblSuppNum = 0;
   let eqNum = 0;
 
-  let orderedFiles;
+  let orderedFiles: string[];
 
   if (Array.isArray(sections) && sections.length > 0) {
     // Use explicitly provided section files - most reliable
-    orderedFiles = sections.filter(f => fs.existsSync(path.join(directory, f)));
+    orderedFiles = sections.filter((f) => fs.existsSync(path.join(directory, f)));
   } else {
     // Try to determine sections from config files (rev.yaml or sections.yaml)
     orderedFiles = discoverSectionFiles(directory);
@@ -291,7 +349,7 @@ export function buildRegistry(directory, sections) {
   }
 
   // Determine if a file is supplementary
-  const isSupplementary = (filename) =>
+  const isSupplementary = (filename: string): boolean =>
     filename.toLowerCase().includes('supp') || filename.toLowerCase().includes('appendix');
 
   // Process each file in order
@@ -301,11 +359,15 @@ export function buildRegistry(directory, sections) {
     const isSupp = isSupplementary(file);
 
     // Find all anchors
-    let match;
+    let match: RegExpExecArray | null;
     ANCHOR_PATTERN.lastIndex = 0;
     while ((match = ANCHOR_PATTERN.exec(content)) !== null) {
-      const type = match[1].toLowerCase();
-      const label = match[2];
+      const typeRaw = match[1];
+      const labelRaw = match[2];
+      if (!typeRaw || !labelRaw) continue;
+
+      const type = typeRaw.toLowerCase();
+      const label = labelRaw;
 
       if (type === 'fig') {
         if (isSupp) {
@@ -325,13 +387,13 @@ export function buildRegistry(directory, sections) {
         }
       } else if (type === 'eq') {
         eqNum++;
-        equations.set(label, { label, num: eqNum, file });
+        equations.set(label, { label, num: eqNum, isSupp: false, file });
       }
     }
   }
 
   // Build reverse lookup: number → label
-  const byNumber = {
+  const byNumber: Registry['byNumber'] = {
     fig: new Map(),
     figS: new Map(),
     tbl: new Map(),
@@ -356,12 +418,14 @@ export function buildRegistry(directory, sections) {
 
 /**
  * Get the display string for a label (e.g., "Figure 1", "Table S2")
- * @param {string} type - "fig", "tbl", "eq"
- * @param {string} label
- * @param {object} registry
- * @returns {string|null}
  */
-export function labelToDisplay(type, label, registry) {
+export function labelToDisplay(
+  type: 'fig' | 'tbl' | 'eq',
+  label: string,
+  registry: Registry
+): string | null {
+  if (!registry || !registry.figures) return null;
+
   const collection =
     type === 'fig' ? registry.figures : type === 'tbl' ? registry.tables : registry.equations;
 
@@ -376,28 +440,32 @@ export function labelToDisplay(type, label, registry) {
 
 /**
  * Get the label for a display number (e.g., "fig:heatmap" from Figure 1)
- * @param {string} type - "fig", "tbl", "eq"
- * @param {number} num
- * @param {boolean} isSupp
- * @param {object} registry
- * @returns {string|null}
  */
-export function numberToLabel(type, num, isSupp, registry) {
-  const key = isSupp ? `${type}S` : type;
+export function numberToLabel(
+  type: 'fig' | 'tbl' | 'eq',
+  num: number,
+  isSupp: boolean,
+  registry: Registry
+): string | null {
+  if (!registry || !registry.byNumber) return null;
+
+  const key = isSupp ? (`${type}S` as keyof Registry['byNumber']) : type;
   return registry.byNumber[key]?.get(num) || null;
 }
 
 /**
  * Detect all hardcoded references in text
- * @param {string} text
- * @returns {Array<{type: string, match: string, numbers: Array<{num: number, isSupp: boolean, suffix: string|null}>, position: number}>}
  */
-export function detectHardcodedRefs(text) {
-  const refs = [];
+export function detectHardcodedRefs(text: string): DetectedRef[] {
+  if (typeof text !== 'string') {
+    throw new TypeError(`text must be a string, got ${typeof text}`);
+  }
+
+  const refs: DetectedRef[] = [];
 
   for (const [type, pattern] of Object.entries(DETECTION_PATTERNS)) {
     pattern.lastIndex = 0;
-    let match;
+    let match: RegExpExecArray | null;
 
     while ((match = pattern.exec(text)) !== null) {
       // Pattern groups:
@@ -405,13 +473,14 @@ export function detectHardcodedRefs(text) {
       // [2] = reference list string (e.g., "1, 2, and 3" or "1a-3b")
 
       const listStr = match[2];
+      if (!listStr) continue;
       const numbers = parseReferenceList(listStr);
 
       // Skip if no valid numbers were parsed
       if (numbers.length === 0) continue;
 
       refs.push({
-        type: normalizeType(type),
+        type: normalizeType(type) as 'fig' | 'tbl' | 'eq',
         match: match[0],
         numbers,
         position: match.index,
@@ -426,22 +495,21 @@ export function detectHardcodedRefs(text) {
 
 /**
  * Convert hardcoded references to @-style references
- * @param {string} text
- * @param {object} registry
- * @returns {{converted: string, conversions: Array<{from: string, to: string}>, warnings: string[]}}
  */
-export function convertHardcodedRefs(text, registry) {
+export function convertHardcodedRefs(text: string, registry: Registry): ConversionResult {
+  // Input validation delegated to detectHardcodedRefs
   const refs = detectHardcodedRefs(text);
-  const conversions = [];
-  const warnings = [];
+  const conversions: Array<{ from: string; to: string }> = [];
+  const warnings: string[] = [];
 
   // Process in reverse order to preserve positions
   let result = text;
   for (let i = refs.length - 1; i >= 0; i--) {
     const ref = refs[i];
+    if (!ref) continue;
 
     // Build replacement
-    const labels = [];
+    const labels: string[] = [];
     for (const { num, isSupp } of ref.numbers) {
       const label = numberToLabel(ref.type, num, isSupp, registry);
       if (label) {
@@ -455,7 +523,18 @@ export function convertHardcodedRefs(text, registry) {
 
     if (labels.length > 0 && !labels.includes(ref.match)) {
       const replacement = labels.join('; ');
-      result = result.slice(0, ref.position) + replacement + result.slice(ref.position + ref.match.length);
+
+      // Skip if the @-syntax already appears in the preceding text
+      // This prevents duplication when import restores @fig:x and then we see "Fig. 1"
+      // e.g., "@fig:map@fig:map{++@fig:map++}" or "@fig:mapFigure 1" patterns
+      const textBefore = result.slice(Math.max(0, ref.position - REF_CONTEXT_WINDOW), ref.position);
+      const alreadyHasRef = labels.some((label) => textBefore.includes(label));
+      if (alreadyHasRef) {
+        continue; // Skip - ref already present nearby
+      }
+
+      result =
+        result.slice(0, ref.position) + replacement + result.slice(ref.position + ref.match.length);
 
       conversions.push({
         from: ref.match,
@@ -469,18 +548,23 @@ export function convertHardcodedRefs(text, registry) {
 
 /**
  * Detect @-style references in text
- * @param {string} text
- * @returns {Array<{type: string, label: string, match: string, position: number}>}
  */
-export function detectDynamicRefs(text) {
-  const refs = [];
+export function detectDynamicRefs(text: string): DynamicRef[] {
+  if (typeof text !== 'string') {
+    throw new TypeError(`text must be a string, got ${typeof text}`);
+  }
+
+  const refs: DynamicRef[] = [];
   REF_PATTERN.lastIndex = 0;
-  let match;
+  let match: RegExpExecArray | null;
 
   while ((match = REF_PATTERN.exec(text)) !== null) {
+    const type = match[1];
+    const label = match[2];
+    if (!type || !label) continue;
     refs.push({
-      type: match[1],
-      label: match[2],
+      type: type as 'fig' | 'tbl' | 'eq',
+      label: label,
       match: match[0],
       position: match.index,
     });
@@ -491,28 +575,23 @@ export function detectDynamicRefs(text) {
 
 /**
  * Get reference status for a file/text
- * @param {string} text
- * @param {object} registry
- * @returns {{
- *   dynamic: Array,
- *   hardcoded: Array,
- *   anchors: {figures: number, tables: number, equations: number}
- * }}
  */
-export function getRefStatus(text, registry) {
+export function getRefStatus(text: string, registry: Registry): RefStatus {
   const dynamic = detectDynamicRefs(text);
-  const hardcoded = detectHardcodedRefs(text);
+  const hardcoded = detectHardcodedRefs(text) as HardcodedRef[];
 
   // Count anchors in this text
   ANCHOR_PATTERN.lastIndex = 0;
   let figCount = 0,
     tblCount = 0,
     eqCount = 0;
-  let match;
+  let match: RegExpExecArray | null;
   while ((match = ANCHOR_PATTERN.exec(text)) !== null) {
-    if (match[1] === 'fig') figCount++;
-    else if (match[1] === 'tbl') tblCount++;
-    else if (match[1] === 'eq') eqCount++;
+    const type = match[1];
+    if (!type) continue;
+    if (type === 'fig') figCount++;
+    else if (type === 'tbl') tblCount++;
+    else if (type === 'eq') eqCount++;
   }
 
   return {
@@ -525,20 +604,20 @@ export function getRefStatus(text, registry) {
 /**
  * Detect forward references in combined text
  * A forward reference is a @ref that appears before its {#anchor} definition
- *
- * @param {string} text - Combined document text
- * @returns {{
- *   forwardRefs: Array<{type: string, label: string, match: string, position: number}>,
- *   anchorPositions: Map<string, number>
- * }}
  */
-export function detectForwardRefs(text) {
+export function detectForwardRefs(text: string): {
+  forwardRefs: Array<{ type: string; label: string; match: string; position: number }>;
+  anchorPositions: Map<string, number>;
+} {
   // Build map of anchor positions: "fig:label" -> position
-  const anchorPositions = new Map();
+  const anchorPositions = new Map<string, number>();
   ANCHOR_PATTERN.lastIndex = 0;
-  let match;
+  let match: RegExpExecArray | null;
   while ((match = ANCHOR_PATTERN.exec(text)) !== null) {
-    const key = `${match[1]}:${match[2]}`;
+    const type = match[1];
+    const label = match[2];
+    if (!type || !label) continue;
+    const key = `${type}:${label}`;
     // Only store first occurrence (in case of duplicates)
     if (!anchorPositions.has(key)) {
       anchorPositions.set(key, match.index);
@@ -563,31 +642,29 @@ export function detectForwardRefs(text) {
  * Resolve forward references to display format
  * Only resolves refs that appear before their anchor definition
  * Leaves other refs for pandoc-crossref to handle (preserves clickable links)
- *
- * @param {string} text - Combined document text
- * @param {object} registry - Registry from buildRegistry()
- * @returns {{
- *   text: string,
- *   resolved: Array<{from: string, to: string, position: number}>,
- *   unresolved: Array<{ref: string, position: number}>
- * }}
  */
-export function resolveForwardRefs(text, registry) {
+export function resolveForwardRefs(
+  text: string,
+  registry: Registry
+): {
+  text: string;
+  resolved: Array<{ from: string; to: string; position: number }>;
+  unresolved: Array<{ ref: string; position: number }>;
+} {
   const { forwardRefs } = detectForwardRefs(text);
-  const resolved = [];
-  const unresolved = [];
+  const resolved: Array<{ from: string; to: string; position: number }> = [];
+  const unresolved: Array<{ ref: string; position: number }> = [];
 
   // Process in reverse order to preserve positions
   let result = text;
   for (let i = forwardRefs.length - 1; i >= 0; i--) {
     const ref = forwardRefs[i];
-    const display = labelToDisplay(ref.type, ref.label, registry);
+    if (!ref) continue;
+    const display = labelToDisplay(ref.type as 'fig' | 'tbl' | 'eq', ref.label, registry);
 
     if (display) {
       result =
-        result.slice(0, ref.position) +
-        display +
-        result.slice(ref.position + ref.match.length);
+        result.slice(0, ref.position) + display + result.slice(ref.position + ref.match.length);
       resolved.push({
         from: ref.match,
         to: display,
@@ -606,11 +683,9 @@ export function resolveForwardRefs(text, registry) {
 
 /**
  * Format registry for display
- * @param {object} registry
- * @returns {string}
  */
-export function formatRegistry(registry) {
-  const lines = [];
+export function formatRegistry(registry: Registry): string {
+  const lines: string[] = [];
 
   if (registry.figures.size > 0) {
     lines.push('Figures:');