@jpeakai/prose-gates 0.1.1 → 0.1.2

package/dist/index.js

@@ -9981,7 +9981,6 @@ var buildDocModel = (src) => {
       texts.push({
         value: t.value,
         line: t.position?.start.line ?? 0,
-        offset: start,
         start,
         end,
         block: ancestors.findLast((a) => a.type === "paragraph" || a.type === "heading" || a.type === "tableCell")
@@ -10008,24 +10007,109 @@ var buildDocModel = (src) => {
   }
   return { src, tree, paragraphs, texts, fences };
 };
+
+// src/text.ts
+var first = (xs) => xs[0];
+var last = (xs) => xs[xs.length - 1];
+var within = (r, span) => r[0] >= span[0] && r[1] <= span[1];
+var collapse = (s) => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
+var countOf = (text4, pattern) => [...text4.matchAll(pattern)].length;
+var spansBetween = (cuts, end) => cuts.map((cut, i) => {
+  const next = cuts[i + 1];
+  return [cut[1], next ? next[0] : end];
+});
+var words = (text4) => text4.split(/\s+/).filter(Boolean).length;
 var inRanges = (offset, ranges) => ranges.some(([a, b]) => offset >= a && offset < b);
 var sentences = (text4) => text4.split(/(?<=[.!?])\s+/).map((s) => s.trim()).filter((s) => s.length > 0);
 
-// src/rules/interpunct.ts
+// src/query.ts
+var proseParagraphs = (doc) => doc.paragraphs.filter((view) => !view.inTable);
+var proseSentences = (doc) => proseParagraphs(doc).flatMap((view) => sentences(view.prose).map((sentence) => ({ view, sentence })));
+var textsContaining = (doc, glyph) => doc.texts.filter((text4) => text4.value.includes(glyph));
+var matchesIn = (src, text4, pattern) => {
+  const slice = src.slice(text4.start, text4.end);
+  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
+  const inSlice = [...slice.matchAll(new RegExp(pattern.source, flags))];
+  const inValue = [...text4.value.matchAll(new RegExp(pattern.source, flags))];
+  if (inSlice.length !== inValue.length)
+    return null;
+  return inSlice.map((m) => [text4.start + (m.index ?? 0), text4.start + (m.index ?? 0) + m[0].length]);
+};
+var matchesInAll = (src, texts, pattern) => {
+  const out = [];
+  for (const t of texts) {
+    const found = matchesIn(src, t, pattern);
+    if (found === null)
+      return null;
+    out.push(...found);
+  }
+  return out;
+};
+var escaped = (src, offset) => src[offset - 1] === "\\";
+var splittableSeparators = (src, view, separator, glyph) => {
+  const found = matchesInAll(src, view.directTexts, separator);
+  if (found === null)
+    return null;
+  if (found.length !== countOf(view.prose, glyph))
+    return null;
+  if (found.some(([start]) => escaped(src, start)))
+    return null;
+  return found;
+};
+var boundaries = (src, view) => {
+  const out = [];
+  for (const t of view.directTexts) {
+    const slice = src.slice(t.start, t.end);
+    for (const m of slice.matchAll(/[.!?]+(\s+)/g)) {
+      const at = t.start + (m.index ?? 0);
+      out.push([at + m[0].length - (m[1]?.length ?? 0), at + m[0].length]);
+    }
+  }
+  return out.sort((a, b) => a[0] - b[0]);
+};
+var sentenceSpan = (src, view, from, to) => {
+  let start = view.startOffset;
+  let end = view.endOffset;
+  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
+    if (nextStart <= from)
+      start = nextStart;
+    if (terminalEnd >= to && end === view.endOffset)
+      end = terminalEnd;
+  }
+  return [start, end];
+};
+var sentenceSpans = (src, view) => {
+  const spans = [];
+  let start = view.startOffset;
+  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
+    spans.push([start, terminalEnd]);
+    start = nextStart;
+  }
+  spans.push([start, view.endOffset]);
+  return spans;
+};
+var colonsIn = (src, view) => matchesInAll(src, view.directTexts, /:/);
+var colonsBefore = (colons, range, item) => colons.filter((colon) => within(colon, range) && colon[1] <= item);
+
+// src/interpunct.ts
+var INTERPUNCT = "·";
+var GLYPH = /·/g;
+var RUN_SEPARATOR = /[ \t]*·[ \t]*/;
 var interpunctRuns = (doc) => {
   const runs = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable)
+  for (const view of proseParagraphs(doc)) {
+    const separators = countOf(view.prose, GLYPH);
+    if (separators < 2)
       continue;
-    const separators = (p.prose.match(/·/g) ?? []).length;
-    if (separators >= 2) {
-      const lines = p.raw.split(`
-`).filter((l) => l.includes("·")).length;
-      runs.push({ range: [p.startOffset, p.endOffset], line: p.line, separators, lines });
-    }
+    const lines = view.raw.split(`
+`).filter((line) => line.includes(INTERPUNCT)).length;
+    runs.push({ range: [view.startOffset, view.endOffset], line: view.line, separators, lines });
   }
   return runs;
 };
+var isFlat = (run) => run.lines === 1;
+var isStacked = (run) => run.lines >= 2;
+var paragraphsOf = (doc, runs) => doc.paragraphs.filter((view) => runs.some((run) => run.range[0] === view.startOffset));
 
 // src/rules/types.ts
 var RULE = {
@@ -10043,56 +10127,68 @@ var CATEGORIES = ["sentence", "list", "punctuation"];
 
 // src/rules/pg001-wrap.ts
 var TERMINALS = new Set([".", "!", "?", ":", ";"]);
-var check = ({ doc, file }) => {
-  const findings = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable)
-      continue;
-    for (let i = 0;i < p.raw.length; i++) {
-      if (p.raw[i] !== `
+var TRAILING = new Set([" ", "\t", "\r", "\\"]);
+var SENTENCE_BREAK = /[.!?]\s+(?=[A-Z`"'([])/g;
+var wrapsIn = (view) => {
+  const wraps = [];
+  for (let i = 0;i < view.raw.length; i++) {
+    if (view.raw[i] !== `
 `)
-        continue;
-      if (inRanges(p.startOffset + i, p.codeRanges))
-        continue;
-      let j = i - 1;
-      while (j >= 0 && (p.raw[j] === " " || p.raw[j] === "\t" || p.raw[j] === "\r" || p.raw[j] === "\\"))
-        j--;
-      if (j >= 0 && !TERMINALS.has(p.raw[j])) {
-        const line = p.line + p.raw.slice(0, i).split(`
-`).length - 1;
-        findings.push({ file, line, rule: RULE.WRAP, message: "mid-sentence line wrap; write one sentence per line" });
-      }
-    }
+      continue;
+    if (inRanges(view.startOffset + i, view.codeRanges))
+      continue;
+    let j = i - 1;
+    while (j >= 0 && TRAILING.has(view.raw.charAt(j)))
+      j--;
+    if (j >= 0 && !TERMINALS.has(view.raw.charAt(j)))
+      wraps.push(i);
   }
-  return findings;
+  return wraps;
 };
-var fix = (doc) => {
-  const edits = [];
-  const stacked = interpunctRuns(doc).filter((r) => r.lines >= 2).map((r) => r.range[0]);
-  for (const p of doc.paragraphs) {
-    if (p.inTable || p.inBlockquote || p.hasBreak || stacked.includes(p.startOffset))
-      continue;
-    const indent2 = " ".repeat(p.startColumn - 1);
-    const eol = p.raw.includes(`\r
+var reflow = (view) => {
+  const indent2 = " ".repeat(view.startColumn - 1);
+  const eol = view.raw.includes(`\r
 `) ? `\r
 ` : `
 `;
-    const masked = [...p.raw].map((ch, i) => inRanges(p.startOffset + i, p.codeRanges) && !/\s/.test(ch) ? "x" : ch).join("");
-    const join = (s) => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
-    const joined = join(p.raw);
-    const joinedMask = join(masked);
-    const out = [];
-    let last = 0;
-    for (const m of joinedMask.matchAll(/[.!?]\s+(?=[A-Z`"'([])/g)) {
-      const at = m.index ?? 0;
-      out.push(joined.slice(last, at + 1));
-      last = at + m[0].length;
-    }
-    out.push(joined.slice(last));
-    const text4 = out.map((s, i) => i === 0 ? s.trim() : indent2 + s.trim()).join(eol);
-    if (text4 !== p.raw) {
-      edits.push({ rule: RULE.WRAP, start: p.startOffset, end: p.endOffset, text: text4, expect: { kind: "same-tree" } });
-    }
+  const masked = [...view.raw].map((ch, i) => inRanges(view.startOffset + i, view.codeRanges) && !/\s/.test(ch) ? "x" : ch).join("");
+  const joined = collapse(view.raw);
+  const joinedMask = collapse(masked);
+  const lines = [];
+  let from = 0;
+  for (const match of joinedMask.matchAll(SENTENCE_BREAK)) {
+    const at = match.index ?? 0;
+    lines.push(joined.slice(from, at + 1));
+    from = at + match[0].length;
+  }
+  lines.push(joined.slice(from));
+  return lines.map((line, i) => i === 0 ? line.trim() : indent2 + line.trim()).join(eol);
+};
+var check = ({ doc, file }) => proseParagraphs(doc).flatMap((view) => wrapsIn(view).map((at) => ({
+  file,
+  line: view.line + view.raw.slice(0, at).split(`
+`).length - 1,
+  rule: RULE.WRAP,
+  message: "mid-sentence line wrap; write one sentence per line"
+})));
+var fix = ({ doc, runs }) => {
+  const edits = [];
+  const stacked = new Set(paragraphsOf(doc, runs.filter(isStacked)));
+  for (const view of proseParagraphs(doc)) {
+    if (view.inBlockquote || view.hasBreak)
+      continue;
+    if (stacked.has(view))
+      continue;
+    const text4 = reflow(view);
+    if (text4 === view.raw)
+      continue;
+    edits.push({
+      rule: RULE.WRAP,
+      start: view.startOffset,
+      end: view.endOffset,
+      text: text4,
+      expect: { kind: "same-tree" }
+    });
   }
   return edits;
 };
@@ -10107,106 +10203,46 @@ var pg001 = {
 // src/rules/pg002-length.ts
 var CLAUSE_BOUNDARY = /[;:](?=\s+\S)|,\s+(?:and|but|or|so|yet|nor)\b|\b(?:because|although|though|whereas|unless|whenever|wherever|while|when|if|which|who|whom|whose)\b/gi;
 var countClauses = (sentence) => 1 + [...sentence.matchAll(CLAUSE_BOUNDARY)].length;
-var excerpt = (s) => s.length > 60 ? `${s.slice(0, 60)}...` : s;
+var excerpt = (sentence) => sentence.length > 60 ? `${sentence.slice(0, 60)}...` : sentence;
 var lengthMessage = (sentence, maxWords) => {
-  const words = sentence.split(/\s+/).length;
+  const count = words(sentence);
   const clauses = countClauses(sentence);
-  const target = Math.max(2, clauses, Math.ceil(words / maxWords));
+  const target = Math.max(2, clauses, Math.ceil(count / maxWords));
   const clauseNote = `${clauses} potential clause${clauses === 1 ? "" : "s"}`;
-  return `sentence has ${words} words (budget ${maxWords}) and ${clauseNote}; split it into about ${target} shorter sentences, one idea each, rather than compressing the wording: "${excerpt(sentence)}"`;
+  return `sentence has ${count} words (budget ${maxWords}) and ${clauseNote}; split it into about ${target} shorter sentences, one idea each, rather than compressing the wording: "${excerpt(sentence)}"`;
 };
+var check2 = ({ doc, file, maxWords }) => proseSentences(doc).filter(({ sentence }) => words(sentence) > maxWords).map(({ view, sentence }) => ({
+  file,
+  line: view.line,
+  rule: RULE.LENGTH,
+  message: lengthMessage(sentence, maxWords)
+}));
 var pg002 = {
   id: RULE.LENGTH,
   category: "sentence",
   summary: "sentence longer than the word budget (default 25)",
-  check: ({ doc, file, maxWords }) => {
-    const findings = [];
-    for (const p of doc.paragraphs) {
-      if (p.inTable)
-        continue;
-      for (const s of sentences(p.prose)) {
-        if (s.split(/\s+/).length > maxWords) {
-          findings.push({ file, line: p.line, rule: RULE.LENGTH, message: lengthMessage(s, maxWords) });
-        }
-      }
-    }
-    return findings;
-  }
-};
-
-// src/fix/spans.ts
-var matchesIn = (src, text4, pattern) => {
-  const slice = src.slice(text4.start, text4.end);
-  const flags = pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`;
-  const inSlice = [...slice.matchAll(new RegExp(pattern.source, flags))];
-  const inValue = [...text4.value.matchAll(new RegExp(pattern.source, flags))];
-  if (inSlice.length !== inValue.length)
-    return null;
-  return inSlice.map((m) => [text4.start + (m.index ?? 0), text4.start + (m.index ?? 0) + m[0].length]);
-};
-var matchesInAll = (src, texts, pattern) => {
-  const out = [];
-  for (const t of texts) {
-    const found = matchesIn(src, t, pattern);
-    if (found === null)
-      return null;
-    out.push(...found);
-  }
-  return out;
-};
-var boundaries = (src, view) => {
-  const out = [];
-  for (const t of view.directTexts) {
-    const slice = src.slice(t.start, t.end);
-    for (const m of slice.matchAll(/[.!?]+(\s+)/g)) {
-      const at = t.start + (m.index ?? 0);
-      out.push([at + m[0].length - (m[1]?.length ?? 0), at + m[0].length]);
-    }
-  }
-  return out.sort((a, b) => a[0] - b[0]);
+  check: check2
 };
-var sentenceSpan = (src, view, from, to) => {
-  let start = view.startOffset;
-  let end = view.endOffset;
-  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
-    if (nextStart <= from)
-      start = nextStart;
-    if (terminalEnd >= to && end === view.endOffset)
-      end = terminalEnd;
-  }
-  return [start, end];
-};
-var sentenceSpans = (src, view) => {
-  const spans = [];
-  let start = view.startOffset;
-  for (const [terminalEnd, nextStart] of boundaries(src, view)) {
-    spans.push([start, terminalEnd]);
-    start = nextStart;
-  }
-  spans.push([start, view.endOffset]);
-  return spans;
-};
-var within = (r, span) => r[0] >= span[0] && r[1] <= span[1];
-var collapse = (s) => s.replace(/[ \t]*\r?\n[ \t]*/g, " ");
-var escaped = (src, offset) => src[offset - 1] === "\\";
 
 // src/fix/promote.ts
 var UNSAFE_START = /^(?:[-+*](?:\s|$)|#{1,6}(?:\s|$)|>|\d{1,9}[.)](?:\s|$)|`{3}|~{3}|<|\||[-_*=](?:\s*[-_*=]){2,}\s*$)/;
 var CONJUNCTION_HEAD = /^(?:and|or)\s+/i;
 var CONJUNCTION_TAIL = /\s+(?:and|or)$/i;
-var cleanItem = (raw, { last }) => {
+var cleanItem = (raw, { last: last2 }) => {
   let s = collapse(raw).trim();
   for (let prev = "";prev !== s; ) {
     prev = s;
     s = s.replace(/[;,]+$/, "").trim();
     s = s.replace(CONJUNCTION_TAIL, "").trim();
-    if (last)
+    if (last2)
       s = s.replace(CONJUNCTION_HEAD, "").trim();
   }
-  if (last)
+  if (last2)
     s = s.replace(/(?<!\.)\.$/, "").trim();
   return s;
 };
+var itemsOf = (src, spans) => spans.map((span, i) => cleanItem(src.slice(span[0], span[1]), { last: i + 1 === spans.length }));
+var itemsBetween = (src, cuts, end) => itemsOf(src, spansBetween(cuts, end));
 var cleanLeadIn = (raw) => {
   const s = collapse(raw).trim().replace(/[\s:;,—-]+$/, "").trim();
   return s.length > 0 ? `${s}:` : null;
@@ -10259,52 +10295,35 @@ ${list2}`;
 };
 
 // src/rules/pg003-semicolon-list.ts
-var check2 = ({ doc, file }) => {
-  const findings = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable)
-      continue;
-    for (const s of sentences(p.prose)) {
-      const semis = (s.match(/;/g) ?? []).length;
-      if (semis >= 2) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.SEMICOLON_LIST,
-          message: `semicolon-delimited list (${semis} ';'); promote to a bullet list`
-        });
-      }
-    }
-  }
-  return findings;
-};
-var fix2 = (doc) => {
-  const edits = [];
+var SEMICOLON = /;/g;
+var check3 = ({ doc, file }) => proseSentences(doc).map(({ view, sentence }) => ({ view, semicolons: countOf(sentence, SEMICOLON) })).filter(({ semicolons }) => semicolons >= 2).map(({ view, semicolons }) => ({
+  file,
+  line: view.line,
+  rule: RULE.SEMICOLON_LIST,
+  message: `semicolon-delimited list (${semicolons} ';'); promote to a bullet list`
+}));
+var fix2 = ({ doc }) => {
   const { src } = doc;
+  const edits = [];
   for (const view of doc.paragraphs) {
-    const semis = matchesInAll(src, view.directTexts, /;/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    if (semis === null || colons === null)
+    const semicolons = matchesInAll(src, view.directTexts, SEMICOLON);
+    const colons = colonsIn(src, view);
+    if (semicolons === null || colons === null)
       continue;
     for (const span of sentenceSpans(src, view)) {
-      const inside = semis.filter((r) => within(r, span));
+      const inside = semicolons.filter((semicolon) => within(semicolon, span));
       if (inside.length < 2)
         continue;
-      const colon = colons.find((r) => within(r, span) && r[1] <= inside[0][0]);
+      const colon = colonsBefore(colons, span, first(inside)[0])[0];
       if (!colon)
         continue;
-      const cuts = [colon, ...inside];
-      const items = cuts.map((cut, i) => {
-        const end = i + 1 < cuts.length ? cuts[i + 1][0] : span[1];
-        return { text: cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length }) };
-      });
       const edit = promote({
         rule: RULE.SEMICOLON_LIST,
         src,
         view,
         span,
         leadIn: cleanLeadIn(src.slice(span[0], colon[0])),
-        items,
+        items: itemsBetween(src, [colon, ...inside], span[1]).map((text4) => ({ text: text4 })),
         ordered: false
       });
       if (edit)
@@ -10318,115 +10337,124 @@ var pg003 = {
   id: RULE.SEMICOLON_LIST,
   category: "list",
   summary: "semicolon-delimited list (2+ ';' in one sentence)",
-  check: check2,
+  check: check3,
   fix: fix2
 };
 
 // src/rules/pg004-em-dash.ts
-var DASH = /[\p{Zs}\t\u200b]*—[\p{Zs}\t\u200b]*/u;
+var EM_DASH = "—";
+var DASH = /[\p{Zs}\t​]*—[\p{Zs}\t​]*/u;
 var MARKER_LIKE = /^(?:[a-z]|[ivx]+|\d+)$/i;
-var fix3 = (doc) => {
-  const { src } = doc;
+var blocksOf = (doc) => {
   const byBlock = new Map;
-  for (const t of doc.texts) {
-    if (t.block === undefined || t.start === undefined || t.end === undefined)
+  for (const { block, start, end, value: value2 } of doc.texts) {
+    if (block === undefined || start === undefined || 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);
+    let entry = byBlock.get(block);
+    if (!entry) {
+      entry = { texts: [], dashes: [], refused: false };
+      byBlock.set(block, entry);
+    }
+    const text4 = { value: value2, start, end };
+    entry.texts.push(text4);
+    const found = matchesIn(doc.src, text4, DASH);
     if (found === null)
       entry.refused = true;
     else
-      entry.dashes.push(...found.map((range) => ({ range, text: t })));
+      entry.dashes.push(...found.map((range) => ({ range, text: text4 })));
   }
-  const edits = [];
-  for (const { texts, dashes, refused } of byBlock.values()) {
-    if (refused || dashes.length === 0)
-      continue;
-    const terminals = [];
-    const colons = [];
-    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 + (m.index ?? 0));
-      for (const m of slice.matchAll(/:/g))
-        colons.push(t.start + (m.index ?? 0));
-    }
-    const sentenceOf = (offset) => terminals.filter((x) => x < offset).length;
-    const groups = new Map;
-    for (const d of dashes) {
-      const key = sentenceOf(d.range[0]);
-      groups.set(key, [...groups.get(key) ?? [], d]);
-    }
-    for (const [sentence, group] of groups) {
-      const edit = rewrite(src, group, sentence, sentenceOf, colons);
-      if (edit)
-        edits.push(edit);
-    }
+  return [...byBlock.values()];
+};
+var offsetsIn = (src, texts, pattern) => texts.flatMap((text4) => [...src.slice(text4.start, text4.end).matchAll(pattern)].map((m) => text4.start + (m.index ?? 0)));
+var asidesIn = (src, { texts, dashes }) => {
+  const terminals = offsetsIn(src, texts, /[.!?](?=\s)/g);
+  const colons = offsetsIn(src, texts, /:/g);
+  const sentenceOf = (offset) => terminals.filter((terminal) => terminal < offset).length;
+  const bySentence = new Map;
+  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)
+  }));
 };
-var rewrite = (src, group, sentence, sentenceOf, colons) => {
-  const first = group[0];
-  const last = group[group.length - 1];
-  const touchesEdge = (d) => d.range[0] === d.text.start || d.range[1] === d.text.end || /[\r\n.!?:;,(\\]/.test(src[d.range[0] - 1] ?? `
-`) || /[\r\n.!?:;,)]/.test(src[d.range[1]] ?? `
+var touchesEdge = (src, dash) => dash.range[0] === dash.text.start || dash.range[1] === dash.text.end || /[\r\n.!?:;,(\\]/.test(src[dash.range[0] - 1] ?? `
+`) || /[\r\n.!?:;,)]/.test(src[dash.range[1]] ?? `
 `);
-  if (group.some(touchesEdge))
+var replacementFor = (src, { dashes, hasColon }) => {
+  const opening = first(dashes);
+  const closing = last(dashes);
+  if (dashes.length === 2) {
+    const inner = src.slice(opening.range[1], closing.range[0]);
+    return MARKER_LIKE.test(inner.trim()) ? null : ` (${inner}) `;
+  }
+  if (dashes.length === 1) {
+    const numericRange = /\d/.test(src[opening.range[0] - 1] ?? "") && /\d/.test(src[opening.range[1]] ?? "");
+    return numericRange || hasColon ? null : ": ";
+  }
+  return null;
+};
+var rewrite = (src, aside) => {
+  if (aside.dashes.some((dash) => touchesEdge(src, dash)))
     return null;
-  let text4;
-  if (group.length === 2) {
-    const inner = src.slice(first.range[1], last.range[0]);
-    if (MARKER_LIKE.test(inner.trim()))
-      return null;
-    text4 = ` (${inner}) `;
-  } else if (group.length === 1) {
-    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;
-    text4 = ": ";
-  } else {
+  const text4 = replacementFor(src, aside);
+  if (text4 === 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: text4,
     expect: { kind: "same-shape" }
   };
 };
+var check4 = ({ doc, file }) => textsContaining(doc, EM_DASH).map((text4) => ({
+  file,
+  line: text4.line,
+  rule: RULE.EM_DASH,
+  message: "em-dash in prose; use comma, colon, parentheses, or two sentences"
+}));
+var fix3 = ({ 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 !== null);
 var pg004 = {
   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: check4,
   fix: fix3
 };
 
 // src/rules/pg005-interpunct.ts
-var fix4 = (doc) => {
-  const runs = interpunctRuns(doc).map((r) => r.range);
+var SEPARATOR = /[ \t]+·[ \t]+/;
+var check5 = ({ doc, file, runs }) => {
+  const reported = runs.map((run) => run.range);
+  return textsContaining(doc, INTERPUNCT).filter((text4) => text4.start === undefined || !inRanges(text4.start, reported)).map((text4) => ({
+    file,
+    line: text4.line,
+    rule: RULE.INTERPUNCT,
+    message: "interpunct in prose; use a comma, slash, or a list"
+  }));
+};
+var fix4 = ({ doc, runs }) => {
+  const reported = runs.map((run) => run.range);
   const edits = [];
-  for (const t of doc.texts) {
-    if (t.start === undefined || t.end === undefined || !t.value.includes("·"))
+  for (const { start, end, value: value2 } of textsContaining(doc, INTERPUNCT)) {
+    if (start === undefined || end === undefined)
       continue;
-    if (inRanges(t.start, runs))
+    if (inRanges(start, reported))
       continue;
-    const text4 = { value: t.value, start: t.start, end: t.end };
-    const glyphs = matchesIn(doc.src, text4, /·/);
-    const spaced = matchesIn(doc.src, text4, /[ \t]+·[ \t]+/);
-    if (glyphs === null || spaced === null || glyphs.length !== spaced.length)
+    const text4 = { value: value2, start, end };
+    const glyphs = matchesIn(doc.src, text4, GLYPH);
+    const separators = matchesIn(doc.src, text4, SEPARATOR);
+    if (glyphs === null || separators === null || glyphs.length !== separators.length)
       continue;
-    for (const [start, end] of spaced) {
-      edits.push({ rule: RULE.INTERPUNCT, start, end, text: ", ", expect: { kind: "same-shape" } });
+    for (const [from, to] of separators) {
+      edits.push({ rule: RULE.INTERPUNCT, start: from, end: to, text: ", ", expect: { kind: "same-shape" } });
     }
   }
   return edits;
@@ -10435,51 +10463,33 @@ var pg005 = {
   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: check5,
   fix: fix4
 };
 
 // src/rules/pg006-interpunct-run.ts
-var words = (s) => s.split(/\s+/).filter(Boolean).length;
-var tailIsProse = (items) => {
-  const last = words(items[items.length - 1] ?? "");
-  const others = Math.max(...items.slice(0, -1).map(words));
-  return last > Math.max(8, 3 * others);
-};
-var headIsProse = (items) => {
-  const first = words(items[0] ?? "");
-  return first > Math.max(...items.slice(1).map(words));
-};
-var fix5 = (doc) => {
+var tailIsProse = (items) => words(last(items)) > Math.max(8, 3 * Math.max(...items.slice(0, -1).map(words)));
+var headIsProse = (items) => words(first(items)) > Math.max(...items.slice(1).map(words));
+var check6 = ({ 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`
+}));
+var fix5 = ({ doc, runs }) => {
   const { src } = doc;
   const edits = [];
-  const runs = interpunctRuns(doc).filter((r) => r.lines === 1);
-  for (const view of doc.paragraphs) {
-    if (!runs.some((r) => r.range[0] === view.startOffset))
+  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 seps = matchesInAll(src, view.directTexts, /[ \t]*·[ \t]*/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
-    if (seps === null || colons === null || seps.length !== (view.prose.match(/·/g) ?? []).length || seps.some(([s]) => escaped(src, s)))
-      continue;
-    const first = seps[0];
-    const last = seps[seps.length - 1];
-    const span = sentenceSpan(src, view, first[0], last[1]);
-    const colon = colons.filter((c) => within(c, span) && c[1] <= first[0]).pop();
+    const span = sentenceSpan(src, view, first(separators)[0], last(separators)[1]);
+    const colon = colonsBefore(colons, span, first(separators)[0]).pop();
     if (!colon && (span[0] !== view.startOffset || span[1] !== view.endOffset))
       continue;
-    const cuts = [colon ?? [span[0], span[0]], ...seps];
-    const items = cuts.map((cut, i) => {
-      const end = i + 1 < cuts.length ? cuts[i + 1][0] : span[1];
-      return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
-    });
+    const cuts = [colon ?? [span[0], span[0]], ...separators];
+    const items = itemsBetween(src, cuts, span[1]);
     if (tailIsProse(items) || !colon && headIsProse(items))
       continue;
     const edit = promote({
@@ -10500,12 +10510,7 @@ var pg006 = {
   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: check6,
   fix: fix5
 };
 
@@ -10517,62 +10522,74 @@ var ENUM_FAMILIES = [
 ];
 var ROMAN = ["i", "ii", "iii", "iv", "v", "vi", "vii", "viii", "ix", "x", "xi", "xii"];
 var LETTERS = [..."abcdefghijklmnopqrstuvwxyz"];
-var sequenceFor = (first) => {
-  if (first === "a")
+var sequenceFor = (label) => {
+  if (label === "a")
     return LETTERS;
-  if (first === "1")
+  if (label === "1")
     return Array.from({ length: 99 }, (_, i) => String(i + 1));
-  if (first === "i")
+  if (label === "i")
     return ROMAN;
   return null;
 };
 var MARKER = /\(([a-z]|[ivx]+|\d{1,2})\)(?=\s)/g;
 var markersIn = (src, texts) => {
-  const out = [];
-  for (const t of texts) {
-    const slice = src.slice(t.start, t.end);
-    const opening = (s) => [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s[(m.index ?? 0) - 1]));
-    const inSlice = opening(slice);
-    if (inSlice.length !== opening(t.value).length)
+  const opening = (s) => [...s.matchAll(MARKER)].filter((m) => (m.index ?? 0) === 0 || /\s/.test(s.charAt((m.index ?? 0) - 1)));
+  const markers2 = [];
+  for (const text4 of texts) {
+    const inSlice = opening(src.slice(text4.start, text4.end));
+    if (inSlice.length !== opening(text4.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] });
+    for (const match of inSlice) {
+      const start = text4.start + (match.index ?? 0);
+      markers2.push({ range: [start, start + match[0].length], label: match[1] ?? "" });
     }
   }
-  return out;
+  return markers2;
 };
-var fix6 = (doc) => {
+var familyIn = (prose) => ENUM_FAMILIES.find(([opener2, second]) => prose.includes(opener2) && prose.includes(second));
+var check7 = ({ doc, file }) => proseParagraphs(doc).flatMap((view) => {
+  const family = familyIn(view.prose);
+  if (!family)
+    return [];
+  const [opener2, second] = family;
+  return [
+    {
+      file,
+      line: view.line,
+      rule: RULE.INLINE_ENUM,
+      message: `enumeration ${opener2} ${second} ... inlined in prose; promote to a bullet list`
+    }
+  ];
+});
+var fix6 = ({ doc }) => {
   const { src } = doc;
   const edits = [];
   for (const view of doc.paragraphs) {
     const markers2 = markersIn(src, view.directTexts);
     if (markers2 === null || markers2.length < 2)
       continue;
-    const sequence = sequenceFor(markers2[0].label);
-    if (sequence === null || markers2.some((m, i) => m.label !== sequence[i]))
-      continue;
-    const first = markers2[0];
-    const last = markers2[markers2.length - 1];
-    const between = view.directTexts.map((t) => src.slice(Math.max(t.start, first.range[1]), Math.min(t.end, last.range[0])));
-    if (between.some((s) => /[.!?]\s/.test(s)))
+    const sequence = sequenceFor(first(markers2).label);
+    if (sequence === null || markers2.some((marker, i) => marker.label !== sequence[i]))
       continue;
-    const span = sentenceSpan(src, view, first.range[0], last.range[1]);
-    const announced = /:\s*$/.test(src.slice(span[0], first.range[0]));
-    const separated = /[,;]\s*$/.test(src.slice(markers2[0].range[1], markers2[1].range[0]));
-    if (markers2.length === 2 && !announced && !separated)
+    const opener2 = first(markers2);
+    const closer = last(markers2);
+    const between = view.directTexts.map((text4) => src.slice(Math.max(text4.start, opener2.range[1]), Math.min(text4.end, closer.range[0])));
+    if (between.some((slice) => /[.!?]\s/.test(slice)))
       continue;
-    const items = markers2.map((m, i) => {
-      const end = i + 1 < markers2.length ? markers2[i + 1].range[0] : span[1];
-      return { text: cleanItem(src.slice(m.range[1], end), { last: i + 1 === markers2.length }) };
-    });
+    const span = sentenceSpan(src, view, opener2.range[0], closer.range[1]);
+    if (markers2.length === 2) {
+      const announced = /:\s*$/.test(src.slice(span[0], opener2.range[0]));
+      const separated = /[,;]\s*$/.test(src.slice(opener2.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], opener2.range[0])),
+      items: itemsBetween(src, markers2.map((marker) => marker.range), span[1]).map((text4) => ({ text: text4 })),
       ordered: true
     });
     if (edit)
@@ -10580,77 +10597,65 @@ var fix6 = (doc) => {
   }
   return edits;
 };
-var check3 = ({ doc, file }) => {
-  const findings = [];
-  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;
-};
 var pg007 = {
   id: RULE.INLINE_ENUM,
   category: "list",
   summary: "enumeration markers (a)/(b) or (1)/(2) inlined in prose",
-  check: check3,
+  check: check7,
   fix: fix6
 };
 
 // src/rules/pg008-labelled-run.ts
-var LABELLED_SEGMENT = /^(?:and\s+|or\s+)?(?:[A-Za-z][\w\s-]{0,24}:\s*)?(?:CODE|[A-Z][A-Za-z]*\d[\w/-]*)\s+\S/;
+var JOINER = "(?:and\\s+|or\\s+)?";
+var INTRO = "(?:[A-Za-z][\\w\\s-]{0,24}:\\s*)?";
+var LABEL = "(?:CODE|[A-Z][A-Za-z]*\\d[\\w/-]*)";
+var CONTENT = "\\s+\\S";
+var LABELLED_SEGMENT = new RegExp(`^${JOINER}${INTRO}${LABEL}${CONTENT}`);
+var INTRO_ONLY = /^[A-Za-z][\w\s-]{0,24}$/;
 var asProse = (src, view, range) => {
   let out = "";
   let at = range[0];
-  for (const [a, b] of view.codeRanges) {
-    if (b <= range[0] || a >= range[1])
+  for (const [start, end] of view.codeRanges) {
+    if (end <= range[0] || start >= range[1])
       continue;
-    out += `${src.slice(at, a)}CODE`;
-    at = b;
+    out += `${src.slice(at, start)}CODE`;
+    at = end;
   }
   return collapse(out + src.slice(at, range[1])).trim();
 };
-var fix7 = (doc) => {
+var labelledSegments = (sentence) => sentence.split(/,\s+/).filter((segment) => LABELLED_SEGMENT.test(segment)).length;
+var check8 = ({ doc, file }) => proseSentences(doc).map(({ view, sentence }) => ({ view, labelled: labelledSegments(sentence) })).filter(({ labelled }) => labelled >= 3).map(({ view, labelled }) => ({
+  file,
+  line: view.line,
+  rule: RULE.LABELLED_RUN,
+  message: `comma-joined run of ${labelled} labelled items; promote to a bullet list`
+}));
+var fix7 = ({ doc }) => {
   const { src } = doc;
   const edits = [];
   for (const view of doc.paragraphs) {
     const commas = matchesInAll(src, view.directTexts, /,(?=\s)/);
-    const colons = matchesInAll(src, view.directTexts, /:/);
+    const colons = colonsIn(src, view);
     if (commas === null || colons === null)
       continue;
     for (const span of sentenceSpans(src, view)) {
-      const inside = commas.filter((r) => within(r, span));
+      const inside = commas.filter((comma) => within(comma, span));
       if (inside.length < 2)
         continue;
-      const bounds = inside.map((c, i) => [i === 0 ? span[0] : inside[i - 1][1], c[0]]);
-      bounds.push([inside[inside.length - 1][1], span[1]]);
-      if (!bounds.every((b) => LABELLED_SEGMENT.test(asProse(src, view, b))))
+      const segments = spansBetween([[span[0], span[0]], ...inside], span[1]);
+      if (!segments.every((segment) => LABELLED_SEGMENT.test(asProse(src, view, segment))))
         continue;
-      const firstBound = bounds[0];
-      const colon = colons.find((c) => within(c, firstBound));
-      const intro = colon && /^[A-Za-z][\w\s-]{0,24}$/.test(collapse(src.slice(span[0], colon[0])).trim());
-      if (intro && colon)
-        firstBound[0] = colon[1];
-      const items = bounds.map((b, i) => ({
-        text: cleanItem(src.slice(b[0], b[1]), { last: i + 1 === bounds.length })
-      }));
+      const opening = first(segments);
+      const colon = colons.find((c) => within(c, opening));
+      const intro = colon !== undefined && INTRO_ONLY.test(collapse(src.slice(span[0], colon[0])).trim());
+      const items = intro && colon ? [[colon[1], opening[1]], ...segments.slice(1)] : segments;
       const edit = promote({
         rule: RULE.LABELLED_RUN,
         src,
         view,
         span,
         leadIn: intro && colon ? cleanLeadIn(src.slice(span[0], colon[0])) : null,
-        items,
+        items: itemsOf(src, items).map((text4) => ({ text: text4 })),
         ordered: false
       });
       if (edit)
@@ -10660,66 +10665,53 @@ var fix7 = (doc) => {
   }
   return edits;
 };
-var check4 = ({ doc, file }) => {
-  const findings = [];
-  for (const p of doc.paragraphs) {
-    if (p.inTable)
-      continue;
-    for (const s of sentences(p.prose)) {
-      const labelled = s.split(/,\s+/).filter((seg) => LABELLED_SEGMENT.test(seg)).length;
-      if (labelled >= 3) {
-        findings.push({
-          file,
-          line: p.line,
-          rule: RULE.LABELLED_RUN,
-          message: `comma-joined run of ${labelled} labelled items; promote to a bullet list`
-        });
-      }
-    }
-  }
-  return findings;
-};
 var pg008 = {
   id: RULE.LABELLED_RUN,
   category: "list",
   summary: "comma-joined labelled run (3+ labelled segments)",
-  check: check4,
+  check: check8,
   fix: fix7
 };
 
 // src/rules/pg009-stacked-runs.ts
-var fix8 = (doc) => {
+var linesOf = (view) => {
+  const lines = [];
+  let at = view.startOffset;
+  for (const line of view.raw.split(`
+`)) {
+    lines.push([at, at + line.length]);
+    at += line.length + 1;
+  }
+  return lines;
+};
+var parentOf = (src, line, separators, colons) => {
+  const inside = separators.filter((separator) => within(separator, line));
+  if (inside.length === 0)
+    return null;
+  const colon = colonsBefore(colons, line, first(inside)[0])[0];
+  if (!colon)
+    return null;
+  return {
+    text: collapse(src.slice(line[0], colon[0])).trim(),
+    children: itemsBetween(src, [colon, ...inside], line[1])
+  };
+};
+var check9 = ({ file, runs }) => runs.filter(isStacked).map((run) => ({
+  file,
+  line: run.line,
+  rule: RULE.STACKED_RUNS,
+  message: `interpunct runs stacked on ${run.lines} lines; promote to a nested list`
+}));
+var fix8 = ({ doc, runs }) => {
   const { src } = doc;
   const edits = [];
-  const runs = interpunctRuns(doc).filter((r) => r.lines >= 2);
-  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, /:/);
-    if (seps === null || colons === null || seps.length !== (view.prose.match(/·/g) ?? []).length || seps.some(([s]) => escaped(src, s)))
+  for (const view of paragraphsOf(doc, runs.filter(isStacked))) {
+    const separators = splittableSeparators(src, view, RUN_SEPARATOR, GLYPH);
+    const colons = colonsIn(src, view);
+    if (separators === null || colons === null)
       continue;
-    const lines = [];
-    let at = view.startOffset;
-    for (const line of view.raw.split(`
-`)) {
-      lines.push([at, at + line.length]);
-      at += line.length + 1;
-    }
-    const parents = [];
-    for (const line of lines) {
-      const lineSeps = seps.filter((s) => within(s, line));
-      const colon = colons.find((c) => within(c, line));
-      if (lineSeps.length === 0 || !colon || colon[1] > lineSeps[0][0])
-        break;
-      const label = collapse(src.slice(line[0], colon[0])).trim();
-      const cuts = [colon, ...lineSeps];
-      const children = cuts.map((cut, i) => {
-        const end = i + 1 < cuts.length ? cuts[i + 1][0] : line[1];
-        return cleanItem(src.slice(cut[1], end), { last: i + 1 === cuts.length });
-      });
-      parents.push({ text: label, children });
-    }
+    const lines = linesOf(view);
+    const parents = lines.map((line) => parentOf(src, line, separators, colons)).filter((parent) => parent !== null);
     if (parents.length !== lines.length)
       continue;
     const edit = promote({
@@ -10740,23 +10732,19 @@ var pg009 = {
   id: RULE.STACKED_RUNS,
   category: "list",
   summary: "interpunct runs stacked on several lines (nested list)",
-  check: ({ file, runs }) => runs.filter((r) => r.lines >= 2).map((r) => ({
-    file,
-    line: r.line,
-    rule: RULE.STACKED_RUNS,
-    message: `interpunct runs stacked on ${r.lines} lines; promote to a nested list`
-  })),
+  check: check9,
   fix: fix8
 };
 
 // src/rules/index.ts
 var RULES = [pg001, pg002, pg003, pg004, pg005, pg006, pg007, pg008, pg009];
+var ruleContext = (doc) => ({ doc, runs: interpunctRuns(doc) });
 var FIX_ORDER = [pg009, pg007, pg008, pg006, pg003, pg005, pg004, pg001];
 
 // src/check.ts
 var DEFAULT_MAX_WORDS = 25;
 var checkModel = (doc, file, maxWords) => {
-  const ctx = { doc, file, maxWords, runs: interpunctRuns(doc) };
+  const ctx = { ...ruleContext(doc), file, maxWords };
   const findings = RULES.flatMap((rule) => rule.check(ctx));
   for (const fence2 of doc.fences) {
     for (const f of checkModel(buildDocModel(fence2.value), file, maxWords)) {
@@ -10892,8 +10880,8 @@ var fixMarkdownReport = (src) => {
   const refusedKeys = new Set;
   let current = src;
   for (let pass = 0;pass < MAX_PASSES; pass++) {
-    const doc = buildDocModel(current);
-    const before = { src: current, tree: doc.tree };
+    const ctx = ruleContext(buildDocModel(current));
+    const before = { src: current, tree: ctx.doc.tree };
     const keyOf = (e) => `${e.rule}\x00${current.slice(e.start, e.end)}\x00${e.text}`;
     const attempt = (edits) => {
       const next = splice2(current, edits);
@@ -10907,7 +10895,7 @@ var fixMarkdownReport = (src) => {
     };
     let progressed = false;
     for (const rule of FIX_ORDER) {
-      const edits = (rule.fix?.(doc) ?? []).filter((e) => current.slice(e.start, e.end) !== e.text && !refusedKeys.has(keyOf(e)));
+      const edits = (rule.fix?.(ctx) ?? []).filter((e) => current.slice(e.start, e.end) !== e.text && !refusedKeys.has(keyOf(e)));
       if (edits.length === 0)
         continue;
       const batchable = edits.length > 1 && !overlaps(edits) && edits.every((e) => e.expect.kind !== "replace-paragraph");