@jpeakai/prose-gates 0.1.1 → 0.1.2

package/src/rules/pg004-em-dash.ts

@@ -3,115 +3,153 @@
 // around an aside becomes parentheses, a lone dash becomes a colon, and
 // anything else stays reported for a human.
 
-import { matchesIn } from "../fix/spans.ts";
-import type { DocModel, Range, TextView } from "../model.ts";
+import type { Node } from "mdast";
+import type { DirectText, DocModel } from "../model.ts";
+import { matchesIn, textsContaining } from "../query.ts";
+import { first, last, type Range } from "../text.ts";
 import { type Edit, RULE, type Rule } from "./types.ts";
 
+const EM_DASH = "—";
+
 // Any horizontal space around the dash belongs to it, including no-break and
 // zero-width spaces, or the swap strands one in front of the colon.
-const DASH = /[\p{Zs}\t\u200b]*—[\p{Zs}\t\u200b]*/u;
+const DASH = /[\p{Zs}\t​]*—[\p{Zs}\t​]*/u;
 
-// An aside that reads as an enumeration marker, "(b)", would plant a PG007
-// marker and hide the word from the content fingerprint.
+// What an aside must not be: an enumeration marker in disguise.
 const MARKER_LIKE = /^(?:[a-z]|[ivx]+|\d+)$/i;
 
 interface Dash {
   range: Range; // the dash with its surrounding spaces
-  text: TextView;
+  text: DirectText; // the text node it sits in
+}
+
+// One paragraph, heading or table cell: the dashes it holds and the text
+// nodes they came from. A block whose source and parsed value disagree is
+// refused whole, so a swap never lands next to a glyph the fixer cannot see.
+interface Block {
+  texts: DirectText[];
+  dashes: Dash[];
+  refused: boolean;
 }
 
-const fix = (doc: DocModel): Edit[] => {
-  const { src } = doc;
-  const byBlock = new Map<unknown, { texts: TextView[]; dashes: Dash[]; refused: boolean }>();
-  for (const t of doc.texts) {
-    if (t.block === undefined || t.start === undefined || t.end === undefined) continue;
-    const entry = byBlock.get(t.block) ?? { texts: [], dashes: [], refused: false };
-    byBlock.set(t.block, entry);
-    entry.texts.push(t);
-    const found = matchesIn(src, { value: t.value, start: t.start, end: t.end }, DASH);
+const blocksOf = (doc: DocModel): Block[] => {
+  const byBlock = new Map<Node, Block>();
+  for (const { block, start, end, value } of doc.texts) {
+    if (block === undefined || start === undefined || end === undefined) continue;
+    let entry = byBlock.get(block);
+    if (!entry) {
+      entry = { texts: [], dashes: [], refused: false };
+      byBlock.set(block, entry);
+    }
+    const text: DirectText = { value, start, end };
+    entry.texts.push(text);
+    const found = matchesIn(doc.src, text, DASH);
     if (found === null) entry.refused = true;
-    else entry.dashes.push(...found.map((range) => ({ range, text: t })));
+    else entry.dashes.push(...found.map((range) => ({ range, text })));
   }
+  return [...byBlock.values()];
+};
 
-  const edits: Edit[] = [];
-  for (const { texts, dashes, refused } of byBlock.values()) {
-    if (refused || dashes.length === 0) continue;
-    // Sentence terminals and colons, read only from prose text in this block.
-    const terminals: number[] = [];
-    const colons: number[] = [];
-    for (const t of texts) {
-      const slice = src.slice(t.start, t.end);
-      for (const m of slice.matchAll(/[.!?](?=\s)/g)) terminals.push((t.start as number) + (m.index ?? 0));
-      for (const m of slice.matchAll(/:/g)) colons.push((t.start as number) + (m.index ?? 0));
-    }
-    const sentenceOf = (offset: number): number => terminals.filter((x) => x < offset).length;
-    const groups = new Map<number, Dash[]>();
-    for (const d of dashes) {
-      const key = sentenceOf(d.range[0]);
-      groups.set(key, [...(groups.get(key) ?? []), d]);
-    }
+// Absolute offsets of every match of `pattern` across a block's prose text.
+const offsetsIn = (src: string, texts: DirectText[], pattern: RegExp): number[] =>
+  texts.flatMap((text) =>
+    [...src.slice(text.start, text.end).matchAll(pattern)].map((m) => text.start + (m.index ?? 0)),
+  );
 
-    for (const [sentence, group] of groups) {
-      const edit = rewrite(src, group, sentence, sentenceOf, colons);
-      if (edit) edits.push(edit);
-    }
+// The dashes of one sentence, with the one fact about that sentence the
+// rewrite needs. A pair only reads as an aside when both halves sit in the
+// same sentence, which is why dashes are judged a sentence at a time.
+interface Aside {
+  dashes: Dash[];
+  hasColon: boolean;
+}
+
+const asidesIn = (src: string, { texts, dashes }: Block): Aside[] => {
+  // Terminals and colons are read only from this block's prose text, so one
+  // inside a link, emphasis or code span never splits a sentence.
+  const terminals = offsetsIn(src, texts, /[.!?](?=\s)/g);
+  const colons = offsetsIn(src, texts, /:/g);
+  const sentenceOf = (offset: number): number => terminals.filter((terminal) => terminal < offset).length;
+
+  const bySentence = new Map<number, Dash[]>();
+  for (const dash of dashes) {
+    const sentence = sentenceOf(dash.range[0]);
+    const group = bySentence.get(sentence);
+    if (group) group.push(dash);
+    else bySentence.set(sentence, [dash]);
   }
-  return edits;
+  return [...bySentence].map(([sentence, group]) => ({
+    dashes: group,
+    hasColon: colons.some((colon) => sentenceOf(colon) === sentence),
+  }));
 };
 
-const rewrite = (
-  src: string,
-  group: Dash[],
-  sentence: number,
-  sentenceOf: (offset: number) => number,
-  colons: number[],
-): Edit | null => {
-  const first = group[0] as Dash;
-  const last = group[group.length - 1] as Dash;
-  // A dash touching a line break, the edge of its text node, or punctuation
-  // that already ends or opens a clause has no clear neighbours to join.
-  const touchesEdge = (d: Dash): boolean =>
-    d.range[0] === d.text.start ||
-    d.range[1] === d.text.end ||
-    /[\r\n.!?:;,(\\]/.test(src[d.range[0] - 1] ?? "\n") ||
-    /[\r\n.!?:;,)]/.test(src[d.range[1]] ?? "\n");
-  if (group.some(touchesEdge)) return null;
-
-  let text: string;
-  if (group.length === 2) {
-    const inner = src.slice(first.range[1], last.range[0]);
-    if (MARKER_LIKE.test(inner.trim())) return null;
-    text = ` (${inner}) `;
-  } else if (group.length === 1) {
-    // A numeric range like 1—2 or 2020 — 2021 wants an en-dash, not a colon,
-    // and a sentence that already has a colon would read as two labels.
-    if (/\d/.test(src[first.range[0] - 1] ?? "") && /\d/.test(src[first.range[1]] ?? "")) return null;
-    if (colons.some((c) => sentenceOf(c) === sentence)) return null;
-    text = ": ";
-  } else {
-    return null;
+// A dash touching a line break, the edge of its text node, or punctuation
+// that already ends or opens a clause has no clear neighbours to join.
+const touchesEdge = (src: string, dash: Dash): boolean =>
+  dash.range[0] === dash.text.start ||
+  dash.range[1] === dash.text.end ||
+  /[\r\n.!?:;,(\\]/.test(src[dash.range[0] - 1] ?? "\n") ||
+  /[\r\n.!?:;,)]/.test(src[dash.range[1]] ?? "\n");
+
+// What the dashes of one sentence become, or null when the shape is not one
+// of the two the fix trusts.
+const replacementFor = (src: string, { dashes, hasColon }: Aside): string | null => {
+  const opening = first(dashes);
+  const closing = last(dashes);
+
+  // A pair wraps an aside, so it becomes parentheses. An aside that reads as
+  // "(b)" would plant a PG007 marker and hide the word from the fingerprint.
+  if (dashes.length === 2) {
+    const inner = src.slice(opening.range[1], closing.range[0]);
+    return MARKER_LIKE.test(inner.trim()) ? null : ` (${inner}) `;
   }
+
+  // A lone dash joins two clauses, so it becomes a colon. A numeric range
+  // like 1—2 or 2020 — 2021 wants an en-dash instead, and a sentence that
+  // already has a colon would read as two labels.
+  if (dashes.length === 1) {
+    const numericRange = /\d/.test(src[opening.range[0] - 1] ?? "") && /\d/.test(src[opening.range[1]] ?? "");
+    return numericRange || hasColon ? null : ": ";
+  }
+
+  // Three or more dashes in one sentence is a shape the fix does not claim
+  // to understand, so the finding stays for a human.
+  return null;
+};
+
+const rewrite = (src: string, aside: Aside): Edit | null => {
+  if (aside.dashes.some((dash) => touchesEdge(src, dash))) return null;
+  const text = replacementFor(src, aside);
+  if (text === null) return null;
   return {
     rule: RULE.EM_DASH,
-    start: first.range[0],
-    end: last.range[1],
+    start: first(aside.dashes).range[0],
+    end: last(aside.dashes).range[1],
     text,
     expect: { kind: "same-shape" },
   };
 };
 
+const check: Rule["check"] = ({ doc, file }) =>
+  textsContaining(doc, EM_DASH).map((text) => ({
+    file,
+    line: text.line,
+    rule: RULE.EM_DASH,
+    message: "em-dash in prose; use comma, colon, parentheses, or two sentences",
+  }));
+
+const fix: Rule["fix"] = ({ doc }) =>
+  blocksOf(doc)
+    .filter((block) => !block.refused && block.dashes.length > 0)
+    .flatMap((block) => asidesIn(doc.src, block))
+    .map((aside) => rewrite(doc.src, aside))
+    .filter((edit): edit is Edit => edit !== null);
+
 export const pg004: Rule = {
   id: RULE.EM_DASH,
   category: "punctuation",
   summary: "em-dash U+2014 in prose",
-  check: ({ doc, file }) =>
-    doc.texts
-      .filter((t) => t.value.includes("—"))
-      .map((t) => ({
-        file,
-        line: t.line,
-        rule: RULE.EM_DASH,
-        message: "em-dash in prose; use comma, colon, parentheses, or two sentences",
-      })),
+  check,
   fix,
 };

package/src/rules/pg005-interpunct.ts

@@ -2,23 +2,42 @@
 // PG006 or PG009. The fix swaps a spaced interpunct for a comma; a glyph
 // with no space on either side (a product name, a unit) is left alone.
 
-import { matchesIn } from "../fix/spans.ts";
-import { type DocModel, inRanges } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
+import { GLYPH, INTERPUNCT } from "../interpunct.ts";
+import { matchesIn, textsContaining } from "../query.ts";
+import { inRanges } from "../text.ts";
 import { type Edit, RULE, type Rule } from "./types.ts";
 
-const fix = (doc: DocModel): Edit[] => {
-  const runs = interpunctRuns(doc).map((r) => r.range);
+// Only a separator reads as a comma: the spaces on both sides are what make
+// the glyph a joiner rather than part of a name. PG006 and PG009 split on a
+// looser one, because a run has already proved itself a list.
+const SEPARATOR = /[ \t]+·[ \t]+/;
+
+const check: Rule["check"] = ({ doc, file, runs }) => {
+  const reported = runs.map((run) => run.range);
+  return textsContaining(doc, INTERPUNCT)
+    .filter((text) => text.start === undefined || !inRanges(text.start, reported))
+    .map((text) => ({
+      file,
+      line: text.line,
+      rule: RULE.INTERPUNCT,
+      message: "interpunct in prose; use a comma, slash, or a list",
+    }));
+};
+
+const fix: Rule["fix"] = ({ doc, runs }) => {
+  const reported = runs.map((run) => run.range);
   const edits: Edit[] = [];
-  for (const t of doc.texts) {
-    if (t.start === undefined || t.end === undefined || !t.value.includes("·")) continue;
-    if (inRanges(t.start, runs)) continue;
-    const text = { value: t.value, start: t.start, end: t.end };
-    const glyphs = matchesIn(doc.src, text, /·/);
-    const spaced = matchesIn(doc.src, text, /[ \t]+·[ \t]+/);
-    if (glyphs === null || spaced === null || glyphs.length !== spaced.length) continue;
-    for (const [start, end] of spaced) {
-      edits.push({ rule: RULE.INTERPUNCT, start, end, text: ", ", expect: { kind: "same-shape" } });
+  for (const { start, end, value } of textsContaining(doc, INTERPUNCT)) {
+    if (start === undefined || end === undefined) continue;
+    if (inRanges(start, reported)) continue;
+    const text = { value, start, end };
+    // Every glyph in the node must be a spaced separator. A mixed node holds
+    // at least one the fix would leave behind, so it refuses whole.
+    const glyphs = matchesIn(doc.src, text, GLYPH);
+    const separators = matchesIn(doc.src, text, SEPARATOR);
+    if (glyphs === null || separators === null || glyphs.length !== separators.length) continue;
+    for (const [from, to] of separators) {
+      edits.push({ rule: RULE.INTERPUNCT, start: from, end: to, text: ", ", expect: { kind: "same-shape" } });
     }
   }
   return edits;
@@ -28,16 +47,6 @@ export const pg005: Rule = {
   id: RULE.INTERPUNCT,
   category: "punctuation",
   summary: "interpunct U+00B7 in prose",
-  check: ({ doc, file, runs }) => {
-    const suppressed = runs.map((r) => r.range);
-    return doc.texts
-      .filter((t) => t.value.includes("·") && !(t.offset != null && inRanges(t.offset, suppressed)))
-      .map((t) => ({
-        file,
-        line: t.line,
-        rule: RULE.INTERPUNCT,
-        message: "interpunct in prose; use a comma, slash, or a list",
-      }));
-  },
+  check,
   fix,
 };

package/src/rules/pg006-interpunct-run.ts

@@ -3,54 +3,46 @@
 // Without a colon the run must be the whole paragraph, or there is no way to
 // tell where the first item starts.
 
-import { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { escaped, matchesInAll, sentenceSpan, within } from "../fix/spans.ts";
-import type { DocModel, Range } from "../model.ts";
-import { interpunctRuns } from "./interpunct.ts";
+import { cleanLeadIn, itemsBetween, promote } from "../fix/promote.ts";
+import { GLYPH, isFlat, paragraphsOf, RUN_SEPARATOR } from "../interpunct.ts";
+import { colonsBefore, colonsIn, sentenceSpan, splittableSeparators } from "../query.ts";
+import { first, last, type Range, words } from "../text.ts";
 import { type Edit, RULE, type Rule } from "./types.ts";
 
 // A last item this much longer than every other is a sentence that happens
-// to follow the list, not a member of it. Without a colon, a first item
-// longer than the rest ("Built with Bun") carries a clause the list would
-// strip of its meaning.
-const words = (s: string): number => s.split(/\s+/).filter(Boolean).length;
-const tailIsProse = (items: string[]): boolean => {
-  const last = words(items[items.length - 1] ?? "");
-  const others = Math.max(...items.slice(0, -1).map(words));
-  return last > Math.max(8, 3 * others);
-};
-const headIsProse = (items: string[]): boolean => {
-  const first = words(items[0] ?? "");
-  return first > Math.max(...items.slice(1).map(words));
-};
+// to follow the list, not a member of it.
+const tailIsProse = (items: string[]): boolean =>
+  words(last(items)) > Math.max(8, 3 * Math.max(...items.slice(0, -1).map(words)));
+
+// Without a colon, a first item longer than the rest ("Built with Bun")
+// carries a clause the list would strip of its meaning.
+const headIsProse = (items: string[]): boolean => words(first(items)) > Math.max(...items.slice(1).map(words));
 
-const fix = (doc: DocModel): Edit[] => {
+const check: Rule["check"] = ({ file, runs }) =>
+  runs.filter(isFlat).map((run) => ({
+    file,
+    line: run.line,
+    rule: RULE.INTERPUNCT_RUN,
+    message: `interpunct-joined inline list (${run.separators + 1} items); promote to a bullet list`,
+  }));
+
+const fix: Rule["fix"] = ({ doc, runs }) => {
   const { src } = doc;
   const edits: Edit[] = [];
-  const runs = interpunctRuns(doc).filter((r) => r.lines === 1);
-  for (const view of doc.paragraphs) {
-    if (!runs.some((r) => r.range[0] === view.startOffset)) continue;
-    const seps = matchesInAll(src, view.directTexts, /[ \t]*·[ \t]*/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    // Every separator the check counted must be one a fixer can split on.
-    if (
-      seps === null ||
-      colons === null ||
-      seps.length !== (view.prose.match(/·/g) ?? []).length ||
-      seps.some(([s]) => escaped(src, s))
-    )
-      continue;
-    const first = seps[0] as Range;
-    const last = seps[seps.length - 1] as Range;
-    const span = sentenceSpan(src, view, first[0], last[1]);
-    const colon = colons.filter((c) => within(c, span) && c[1] <= first[0]).pop();
+  for (const view of paragraphsOf(doc, runs.filter(isFlat))) {
+    const separators = splittableSeparators(src, view, RUN_SEPARATOR, GLYPH);
+    const colons = colonsIn(src, view);
+    if (separators === null || colons === null) continue;
+
+    const span = sentenceSpan(src, view, first(separators)[0], last(separators)[1]);
+    // The innermost colon before the first item, so a lead-in that itself
+    // contains a colon keeps only its final clause.
+    const colon = colonsBefore(colons, span, first(separators)[0]).pop();
+    // With no colon to announce it, the run has to be the whole paragraph.
     if (!colon && (span[0] !== view.startOffset || span[1] !== view.endOffset)) continue;
 
-    const cuts: Range[] = [colon ?? [span[0], span[0]], ...seps];
-    const items = cuts.map((cut, i) => {
-      const end = i + 1 < cuts.length ? (cuts[i + 1] as Range)[0] : span[1];
-      return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
-    });
+    const cuts: Range[] = [colon ?? [span[0], span[0]], ...separators];
+    const items = itemsBetween(src, cuts, span[1]);
     if (tailIsProse(items) || (!colon && headIsProse(items))) continue;
 
     const edit = promote({
@@ -71,14 +63,6 @@ export const pg006: Rule = {
   id: RULE.INTERPUNCT_RUN,
   category: "list",
   summary: "interpunct-joined inline list (2+ separators)",
-  check: ({ file, runs }) =>
-    runs
-      .filter((r) => r.lines < 2)
-      .map((r) => ({
-        file,
-        line: r.line,
-        rule: RULE.INTERPUNCT_RUN,
-        message: `interpunct-joined inline list (${r.separators + 1} items); promote to a bullet list`,
-      })),
+  check,
   fix,
 };

package/src/rules/pg007-inline-enum.ts

@@ -3,10 +3,11 @@
 // lone "(a)" reference from firing. The fix only trusts a clean sequence:
 // every marker in order, none skipped, none from another family.
 
-import { cleanItem, cleanLeadIn, promote } from "../fix/promote.ts";
-import { sentenceSpan } from "../fix/spans.ts";
-import type { DocModel, Range } from "../model.ts";
-import { type Edit, type Finding, RULE, type Rule } from "./types.ts";
+import { cleanLeadIn, itemsBetween, promote } from "../fix/promote.ts";
+import type { DirectText } from "../model.ts";
+import { proseParagraphs, sentenceSpan } from "../query.ts";
+import { first, last, type Range } from "../text.ts";
+import { type Edit, RULE, type Rule } from "./types.ts";
 
 const ENUM_FAMILIES: Array<[string, string]> = [
   ["(a)", "(b)"],
@@ -18,10 +19,10 @@ const ROMAN = ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi"
 const LETTERS = [..."abcdefghijklmnopqrstuvwxyz"];
 
 // The expected nth marker for the family the first marker opens.
-const sequenceFor = (first: string): string[] | null => {
-  if (first === "a") return LETTERS;
-  if (first === "1") return Array.from({ length: 99 }, (_, i) => String(i + 1));
-  if (first === "i") return ROMAN;
+const sequenceFor = (label: string): string[] | null => {
+  if (label === "a") return LETTERS;
+  if (label === "1") return Array.from({ length: 99 }, (_, i) => String(i + 1));
+  if (label === "i") return ROMAN;
   return null;
 };
 
@@ -35,55 +36,81 @@ interface Marker {
 // Markers that open an item: preceded by whitespace or the start of a direct
 // text node, and followed by whitespace. The parsed value must agree with the
 // source, or an escape is hiding somewhere and the fixer refuses.
-const markersIn = (src: string, texts: DocModel["paragraphs"][number]["directTexts"]): Marker[] | null => {
-  const out: Marker[] = [];
-  for (const t of texts) {
-    const slice = src.slice(t.start, t.end);
-    const opening = (s: string): RegExpMatchArray[] =>
-      [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s[(m.index ?? 0) - 1] as string));
-    const inSlice = opening(slice);
-    if (inSlice.length !== opening(t.value).length) return null;
-    for (const m of inSlice) {
-      const start = t.start + (m.index ?? 0);
-      out.push({ range: [start, start + m[0].length], label: m[1] as string });
+const markersIn = (src: string, texts: DirectText[]): Marker[] | null => {
+  const opening = (s: string): RegExpMatchArray[] =>
+    [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s.charAt((m.index ?? 0) - 1)));
+
+  const markers: Marker[] = [];
+  for (const text of texts) {
+    const inSlice = opening(src.slice(text.start, text.end));
+    if (inSlice.length !== opening(text.value).length) return null;
+    for (const match of inSlice) {
+      const start = text.start + (match.index ?? 0);
+      markers.push({ range: [start, start + match[0].length], label: match[1] ?? "" });
     }
   }
-  return out;
+  return markers;
 };
 
-const fix = (doc: DocModel): Edit[] => {
+// The first family whose opening two markers both appear, or undefined. One
+// family per paragraph is enough to report it.
+const familyIn = (prose: string): [string, string] | undefined =>
+  ENUM_FAMILIES.find(([opener, second]) => prose.includes(opener) && prose.includes(second));
+
+const check: Rule["check"] = ({ doc, file }) =>
+  proseParagraphs(doc).flatMap((view) => {
+    const family = familyIn(view.prose);
+    if (!family) return [];
+    const [opener, second] = family;
+    return [
+      {
+        file,
+        line: view.line,
+        rule: RULE.INLINE_ENUM,
+        message: `enumeration ${opener} ${second} ... inlined in prose; promote to a bullet list`,
+      },
+    ];
+  });
+
+const fix: Rule["fix"] = ({ doc }) => {
   const { src } = doc;
   const edits: Edit[] = [];
   for (const view of doc.paragraphs) {
     const markers = markersIn(src, view.directTexts);
     if (markers === null || markers.length < 2) continue;
-    const sequence = sequenceFor((markers[0] as Marker).label);
-    if (sequence === null || markers.some((m, i) => m.label !== sequence[i])) continue;
+    const sequence = sequenceFor(first(markers).label);
+    if (sequence === null || markers.some((marker, i) => marker.label !== sequence[i])) continue;
 
-    const first = markers[0] as Marker;
-    const last = markers[markers.length - 1] as Marker;
+    const opener = first(markers);
+    const closer = last(markers);
     // Markers split across sentences are two references, not one list.
-    const between = view.directTexts.map((t) =>
-      src.slice(Math.max(t.start, first.range[1]), Math.min(t.end, last.range[0])),
+    const between = view.directTexts.map((text) =>
+      src.slice(Math.max(text.start, opener.range[1]), Math.min(text.end, closer.range[0])),
     );
-    if (between.some((s) => /[.!?]\s/.test(s))) continue;
-    const span = sentenceSpan(src, view, first.range[0], last.range[1]);
+    if (between.some((slice) => /[.!?]\s/.test(slice))) continue;
+
+    const span = sentenceSpan(src, view, opener.range[0], closer.range[1]);
     // Two markers joined only by a conjunction, with no colon to announce
-    // them, read as cross-references ("see (a) above and (b) below").
-    const announced = /:\s*$/.test(src.slice(span[0], first.range[0]));
-    const separated = /[,;]\s*$/.test(src.slice((markers[0] as Marker).range[1], (markers[1] as Marker).range[0]));
-    if (markers.length === 2 && !announced && !separated) continue;
-    const items = markers.map((m, i) => {
-      const end = i + 1 < markers.length ? (markers[i + 1] as Marker).range[0] : span[1];
-      return { text: cleanItem(src.slice(m.range[1], end), { last: i + 1 === markers.length }) };
-    });
+    // them, read as cross-references ("see (a) above and (b) below"). With
+    // exactly two markers the closer is also the second, so the text between
+    // them is the whole of the first item.
+    if (markers.length === 2) {
+      const announced = /:\s*$/.test(src.slice(span[0], opener.range[0]));
+      const separated = /[,;]\s*$/.test(src.slice(opener.range[1], closer.range[0]));
+      if (!announced && !separated) continue;
+    }
+
     const edit = promote({
       rule: RULE.INLINE_ENUM,
       src,
       view,
       span,
-      leadIn: cleanLeadIn(src.slice(span[0], first.range[0])),
-      items,
+      leadIn: cleanLeadIn(src.slice(span[0], opener.range[0])),
+      items: itemsBetween(
+        src,
+        markers.map((marker) => marker.range),
+        span[1],
+      ).map((text) => ({ text })),
       ordered: true,
     });
     if (edit) edits.push(edit);
@@ -91,25 +118,6 @@ const fix = (doc: DocModel): Edit[] => {
   return edits;
 };
 
-const check: Rule["check"] = ({ doc, file }) => {
-  const findings: Finding[] = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable) continue;
-    for (const [first, second] of ENUM_FAMILIES) {
-      if (p.prose.includes(first) && p.prose.includes(second)) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.INLINE_ENUM,
-          message: `enumeration ${first} ${second} ... inlined in prose; promote to a bullet list`,
-        });
-        break;
-      }
-    }
-  }
-  return findings;
-};
-
 export const pg007: Rule = {
   id: RULE.INLINE_ENUM,
   category: "list",