chaffjs 0.28.0 → 0.29.0

package/src/structure/title-lines.ts

@@ -0,0 +1,33 @@
+import type { MarkupHeading, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "./issues.ts";
+import { lineNumberAt, type Line } from "./lines.ts";
+
+// 題・見出しの行。見出しは節の中身に名前を付けるだけで、本文の文ではない。純関数: 木と行と Markdown の見出しを受け取る。
+
+/** 見出しの行に、見出しの言葉のほかにあってよい字（括弧と空白）。法令の「（解雇の予告）」。 */
+const CAPTION_MARKS = /[\s()（）［］[\]【】〔〕]/gu;
+
+/** 条の前の行が、その条の見出しだけの行か。 */
+const isCaptionLine = (line: Line | undefined, heading: string): boolean =>
+  line !== undefined && heading !== "" && line.text.replaceAll(CAPTION_MARKS, "") === heading.replaceAll(CAPTION_MARKS, "");
+
+const lineNumbersOfTree = (tree: StructureNode, lines: readonly Line[]): number[] =>
+  inDocumentOrder(tree).flatMap((node) => {
+    if (node.kind === "chapter" || node.kind === "section") return [node.line];
+    if (node.kind !== "article") return [];
+    const caption = node.line - 1;
+    return isCaptionLine(lines[caption - 1], String(node.attrs["heading"] ?? "")) ? [caption] : [];
+  });
+
+/**
+ * 題・見出しの行の番号（1 始まり）。Markdown の見出しの行、木の章・節の行、条の前に置いた見出しだけの行。
+ * 条の行の中の見出し（第一条（目的））は条の本文と同じ行なので入れない。
+ */
+export const titleLineNumbers = (tree: StructureNode | undefined, lines: readonly Line[], headings: readonly MarkupHeading[]): ReadonlySet<number> =>
+  new Set([
+    ...(tree === undefined ? [] : lineNumbersOfTree(tree, lines)),
+    ...headings.flatMap((heading) => {
+      const line = lineNumberAt(lines, heading.start);
+      return line === undefined ? [] : [line];
+    }),
+  ]);

package/src/structure/total.ts

@@ -142,6 +142,10 @@ const SIGN_REACH = 2;
 const signBefore = (source: string, total: Placed, start: number): string =>
   total.cents !== undefined && total.cents < 0 ? (SIGN_BEFORE.exec(source.slice(Math.max(0, start - SIGN_REACH), start))?.[0] ?? "") : "";
 
+/** 数の後ろに書いた単位。単位の組の名前（credit）と書いた語（credits）が違えば、書いた語を見せる。 */
+const unitAfterNumber = (written: string, unit: string): string =>
+  written.endsWith(unit) ? unit : written.slice(written.split("").findLastIndex((char) => char >= "0" && char <= "9") + 1);
+
 /** 合計の行に書いた金額と、上の和を、同じ書き方で見せる。負の和には、合計に書いた印（無ければ -）を付ける。 */
 const shownAmounts = (source: string, total: Placed, sumCents: number): Record<string, string> => {
   const unitStart = unitStartBefore(source, total);
@@ -151,7 +155,7 @@ const shownAmounts = (source: string, total: Placed, sumCents: number): Record<s
   const sumSign = sumCents < 0 ? sign || "-" : "";
   const sum = formatCents(Math.abs(sumCents), written);
   if (unitStart !== undefined) return { written, sum: `${sumSign}${source.slice(unitStart, total.offset)}${sum}` };
-  return { written, sum: `${sumSign}${sum}${written.endsWith(total.unit) ? total.unit : ""}` };
+  return { written, sum: `${sumSign}${sum}${unitAfterNumber(written, total.unit)}` };
 };
 
 /** 文の中の合計の金額（符号の無い、単位付きの金額）と和を、合計の書き方で見せる。 */

package/src/structure/version-mismatch.ts

@@ -1,5 +1,6 @@
 // A version written in the lead-in to a code block ("Install version 2.3.0 from npm:") that the block itself does not
 // show (npm install tidyq@2.4.0). Pure: reads the source, the code blocks, and the prose with code covered.
+import { escapeRegExp } from "../orthography.ts";
 import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 
@@ -85,19 +86,72 @@ const leadInOf = (source: string, blockStart: number): Span | undefined => {
   return text === "" || NOT_PROSE.test(text) || !LETTER.test(words) ? undefined : { start, end: lines.length };
 };
 
+/** A pin with the version it pins, of any number of parts: redis 7.4 in redis:7.4-alpine and in library/redis:7.4. */
+const PIN_VERSION = /^([\w.-]+)(?:@|==|=|:)[v^~]?(\d+(?:\.\d+)*)/u;
+const HAS_LETTER = /[A-Za-z]/u;
+
+/** Each name the block pins, with the one version it pins it to; a name pinned to two versions is left out. */
+const pinnedVersions = (code: string): Map<string, string> => {
+  const byName = new Map<string, Set<string>>();
+  codeWords(code).forEach((word) => {
+    const match = PIN_VERSION.exec(word.slice(word.lastIndexOf("/") + 1));
+    if (match?.[1] === undefined || match[2] === undefined || !HAS_LETTER.test(match[1])) return;
+    const name = match[1].toLowerCase();
+    byName.set(name, new Set([...(byName.get(name) ?? []), match[2]]));
+  });
+  const single = new Map<string, string>();
+  byName.forEach((versions, name) => {
+    const [only] = versions;
+    if (versions.size === 1 && only !== undefined) single.set(name, only);
+  });
+  return single;
+};
+
+/** 7 and 7.4, or 7.4 and 7.4.1: one names the other's series, so they agree. */
+const sameSeries = (written: string, pinned: string): boolean => {
+  const [shorter, longer] = [written.split("."), pinned.split(".")].toSorted((left, right) => left.length - right.length);
+  return (shorter ?? []).every((part, index) => part === longer?.[index]);
+};
+
 /**
- * Each version in a code block's lead-in that differs from the one version the block shows. A block with no version, or
- * with two (an upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another
- * program, is not the one installed.
+ * Each version written right after the name of a program the block pins ("We run Redis 7.2" over redis:7.4) that is not of
+ * the pinned version's series. The name says whose version it is, so a version of two parts is read here, where a bare 7.2
+ * is too often a decimal; one part (port 6379, Node 20) is too often another number.
  */
-export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
-  blocks.flatMap((block) => {
-    const shown = [...new Set(versionsIn(block.code).map((found) => found.version))];
-    const leadIn = leadInOf(source, block.start);
-    const [code] = shown;
-    if (shown.length !== 1 || code === undefined || leadIn === undefined) return [];
-    const names = pinnedNames(block.code);
-    return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
-      .filter((found) => found.version !== code && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
-      .map((found) => ({ offset: found.start, values: { written: found.version, code } }));
+const namedMismatches = (prose: string, leadIn: Span, code: string, ranges: readonly RangeWord[]): StructureIssue[] =>
+  [...pinnedVersions(code)].flatMap(([name, pinned]) => {
+    const pattern = new RegExp(`(?<![\\w.-])${escapeRegExp(name)}\\s+v?(\\d+(?:\\.\\d+){1,2})(?![\\w.]|\\.\\d)`, "giu");
+    return [...prose.slice(leadIn.start, leadIn.end).matchAll(pattern)].flatMap((match) => {
+      const written = match[1] ?? "";
+      const span = { start: leadIn.start + match.index, end: leadIn.start + match.index + match[0].length };
+      if (sameSeries(written, pinned) || isBound(prose, span, ranges)) return [];
+      return [{ offset: span.end - written.length, values: { written, code: pinned } }];
+    });
   });
+
+/**
+ * Each version in the lead-in that differs from the one version the block shows. A block with no version, or with two (an
+ * upgrade from one to the other), says nothing to compare; a version marked as a bound, or named after another program, is
+ * not the one installed.
+ */
+const shownMismatches = (prose: string, leadIn: Span, code: string, words: VersionWords): StructureIssue[] => {
+  const shown = [...new Set(versionsIn(code).map((found) => found.version))];
+  const [only] = shown;
+  if (shown.length !== 1 || only === undefined) return [];
+  const names = pinnedNames(code);
+  return versionsIn(prose.slice(leadIn.start, leadIn.end), leadIn.start)
+    .filter((found) => found.version !== only && !isBound(prose, found, words.ranges) && isAboutBlock(prose, found, names, words.versionWords))
+    .map((found) => ({ offset: found.start, values: { written: found.version, code: only } }));
+};
+
+/** Both readings of one block; a version both report is reported once, against the pin of the program it names. */
+const blockMismatches = (source: string, prose: string, block: CodeBlock, words: VersionWords): StructureIssue[] => {
+  const leadIn = leadInOf(source, block.start);
+  if (leadIn === undefined) return [];
+  const issues = [...namedMismatches(prose, leadIn, block.code, words.ranges), ...shownMismatches(prose, leadIn, block.code, words)];
+  return issues.filter((issue, index) => issues.findIndex((other) => other.offset === issue.offset) === index);
+};
+
+/** Each version in a code block's lead-in that differs from the version the block installs. */
+export const versionMismatches = (source: string, prose: string, blocks: readonly CodeBlock[], words: VersionWords): StructureIssue[] =>
+  blocks.flatMap((block) => blockMismatches(source, prose, block, words));

package/src/structure/version-order.ts

@@ -0,0 +1,84 @@
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * Versions listed in order, a changelog's headings or a list of releases, with one out of place. The direction (newest or
+ * oldest first) is taken from most of the steps, and a version that fits in no longest run along it is pointed out.
+ */
+export type VersionPoint = { readonly offset: number; readonly label: string };
+
+type Version = { readonly parts: readonly number[]; readonly prerelease: string };
+
+/** A version at the start of a heading or an item: 3.2.0, v3.2.0, [3.2.0], 3.2.0-beta.1. */
+const VERSION_START = /^\[?v?(\d{1,4})\.(\d{1,4})\.(\d{1,4})(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?\]?(?![\w.])/u;
+
+/** The version a heading or an item starts with, as written; undefined when it does not start with one. */
+export const leadingVersion = (text: string): string | undefined => VERSION_START.exec(text.trim())?.[0];
+
+const parse = (label: string): Version | undefined => {
+  const match = VERSION_START.exec(label);
+  if (match === null) return undefined;
+  return { parts: [match[1], match[2], match[3]].map(Number), prerelease: match[4] ?? "" };
+};
+
+/** A prerelease (3.0.0-beta.1) comes before its release (3.0.0). */
+const comparePrerelease = (left: string, right: string): number => {
+  if (left === right) return 0;
+  if (left === "") return 1;
+  return right === "" ? -1 : Math.sign(left.localeCompare(right, "en", { numeric: true }));
+};
+
+const compareVersions = (left: Version, right: Version): number => {
+  const differing = left.parts.findIndex((part, index) => part !== right.parts[index]);
+  return differing === -1 ? comparePrerelease(left.prerelease, right.prerelease) : Math.sign((left.parts[differing] ?? 0) - (right.parts[differing] ?? 0));
+};
+
+/** The longest run along direction ending at each version (equal versions do not break it). */
+const longestEndingAt = (versions: readonly Version[], direction: number): number[] =>
+  versions.reduce<number[]>((lengths, version, index) => {
+    const along = versions.slice(0, index).map((earlier, at) => (compareVersions(version, earlier) === -direction ? 0 : (lengths[at] ?? 0)));
+    return [...lengths, 1 + Math.max(0, ...along)];
+  }, []);
+
+const majorityOf = (versions: readonly Version[]): number =>
+  Math.sign(versions.slice(1).reduce((sum, version, index) => sum + compareVersions(version, versions[index] ?? version), 0));
+
+/** The fewest versions an order is read from: with two, either one could be the one out of place. */
+const MIN_VERSIONS = 3;
+
+/**
+ * The versions that belong to no longest run along the majority direction. A run that holds no more than half of them is
+ * taken as sorted by something else, and nothing is said.
+ */
+export const versionOrderBreaks = (points: readonly VersionPoint[]): StructureIssue[] => {
+  const parsed = points.flatMap((point) => {
+    const version = parse(point.label);
+    return version === undefined ? [] : [{ point, version }];
+  });
+  const versions = parsed.map((entry) => entry.version);
+  const direction = majorityOf(versions);
+  if (versions.length < MIN_VERSIONS || direction === 0) return [];
+  const forward = longestEndingAt(versions, direction);
+  const backward = longestEndingAt(versions.toReversed(), -direction).toReversed();
+  const longest = Math.max(...forward);
+  if (longest * 2 <= versions.length) return [];
+  return parsed.flatMap((entry, index) =>
+    (forward[index] ?? 0) + (backward[index] ?? 0) - 1 === longest
+      ? []
+      : [{ offset: entry.point.offset, values: { version: entry.point.label, previous: parsed[index - 1]?.point.label ?? "" } }],
+  );
+};
+
+/** A version whose last part is zero (3.1.0) is no section number: the sections under 3.1 count from 3.1.1. */
+const endsInZero = (version: Version): boolean => version.parts.at(-1) === 0;
+
+/**
+ * Whether dotted labels (1.2.1, 1.2.2) are a version history rather than section numbers: all of them versions, and
+ * either one ends in zero or most steps go down (newest first). Section numbers only go up. version-order checks the
+ * histories and numbering-gap the rest, so a sequence is never reported by both.
+ */
+export const isVersionHistory = (labels: readonly string[]): boolean => {
+  const versions = labels.map(parse);
+  const parsed = versions.filter((version) => version !== undefined);
+  if (labels.length < 2 || parsed.length !== labels.length) return false;
+  return parsed.some(endsInZero) || majorityOf(parsed) < 0;
+};

package/src/table-text.ts

@@ -0,0 +1,39 @@
+// The prose with its Markdown tables read back in. The prose masks tables, but a quote or an invoice keeps most of its
+// amounts in one, and a rule comparing how amounts are written has to see them.
+import type { ProseDocument, Span } from "./plugin.ts";
+import { maskSpans } from "./mask.ts";
+import { opaqueSpans, readMarkdown, spansOfType } from "./markdown-read.ts";
+import { TABLE_RULE } from "./structure/runs.ts";
+
+const within = (inner: Span, outer: Span): boolean => inner.start >= outer.start && inner.end <= outer.end;
+
+/**
+ * The prose, with each table span as the source writes it, except what stays hidden inside it (code in a cell). Offsets
+ * are kept. Pure.
+ */
+export const proseWithTables = (prose: string, source: string, tables: readonly Span[], hidden: readonly Span[]): string => {
+  if (tables.length === 0) return prose;
+  const shown = maskSpans(source, hidden);
+  const pieces: string[] = [];
+  const end = tables
+    .toSorted((left, right) => left.start - right.start)
+    .reduce((from, table) => {
+      if (table.start < from) return from;
+      pieces.push(prose.slice(from, table.start), shown.slice(table.start, table.end));
+      return table.end;
+    }, 0);
+  pieces.push(prose.slice(end));
+  return pieces.join("");
+};
+
+const hasTableRule = (source: string): boolean => source.split("\n").some((line) => TABLE_RULE.test(line) && line.includes("-"));
+
+/** The document's prose with its tables, outside code and quoted replies. A document that is not Markdown keeps its prose. */
+export const proseAndTablesOf = (doc: ProseDocument): string => {
+  const prose = doc.prose ?? doc.source;
+  if (doc.prose === undefined || doc.markup?.markdown !== true || !hasTableRule(doc.source)) return prose;
+  const { root } = readMarkdown(doc.source);
+  const quoted = [...spansOfType(root, "blockquote"), ...(doc.replyQuotes ?? [])];
+  const tables = spansOfType(root, "table").filter((table) => !quoted.some((quote) => within(table, quote)));
+  return proseWithTables(doc.prose, doc.source, tables, opaqueSpans(root));
+};

package/src/ui-labels.ts

@@ -0,0 +1,55 @@
+// The same label on the screen written two ways in one manual (**Start Restore** and **Start restore**, ［復元を開始］ and
+// ［復元開始］). Pure: reads the labels a manual marks as labels, bold or in ［］, and points at the form written less often.
+
+import { escapeRegExp } from "./orthography.ts";
+
+export type Label = { readonly surface: string; readonly offset: number };
+export type LabelVariant = { readonly label: Label; readonly usual: string };
+
+/** What a manual marks as a label on the screen: bold (** or __), or the full-width brackets Japanese manuals use. */
+const MARKED = /\*\*([^*\n]{1,40})\*\*|__([^_\n]{1,40})__|［([^］\n]{1,40})］/gu;
+const SPACES = /\s+/gu;
+const LETTER = /\p{L}/u;
+
+/** Each label marked in the source whose text is prose (not covered as code in prose) and holds a letter. */
+export const labelsIn = (source: string, prose: string): Label[] =>
+  [...source.matchAll(MARKED)].flatMap((match) => {
+    const surface = (match[1] ?? match[2] ?? match[3] ?? "").trim();
+    const inner = match.index + match[0].indexOf(surface);
+    const covered = prose.slice(inner, inner + surface.length) !== surface;
+    return covered || !LETTER.test(surface) ? [] : [{ surface, offset: inner }];
+  });
+
+/**
+ * Two forms of one label differ only in case, spaces, or a word a label is written with or without (the label-particle
+ * lexicon: 復元を開始 and 復元開始).
+ */
+const keyOf = (surface: string, particles: readonly string[]): string =>
+  particles.reduce((text, particle) => text.replace(joining(particle), ""), surface.replace(SPACES, "")).toLowerCase();
+
+/** A particle between two kanji or katakana (復元を開始), not one inside a word (その他). */
+const joining = (particle: string): RegExp =>
+  new RegExp(`(?<=[\\p{Script=Han}\\p{Script=Katakana}ー])${escapeRegExp(particle)}(?=[\\p{Script=Han}\\p{Script=Katakana}])`, "gu");
+
+/** Two forms that differ only in the case of their first letter (Note and note): emphasis at a sentence's start, not two labels. */
+const onlyFirstLetterDiffers = (forms: readonly string[]): boolean =>
+  new Set(forms.map((form) => `${form.charAt(0).toLowerCase()}${form.slice(1)}`)).size === 1;
+
+const groupBy = (labels: readonly Label[], keyFor: (label: Label) => string): Map<string, Label[]> =>
+  labels.reduce((groups, label) => groups.set(keyFor(label), [...(groups.get(keyFor(label)) ?? []), label]), new Map<string, Label[]>());
+
+/**
+ * Each label written in a form other than the one its key is written in most; on a tie, the later form. A label written
+ * one way only says nothing.
+ */
+export const labelVariants = (labels: readonly Label[], particles: readonly string[] = []): LabelVariant[] => {
+  const byKey = groupBy(labels, (label) => keyOf(label.surface, particles));
+  return [...byKey.values()].flatMap((group) => {
+    const counts = groupBy(group, (label) => label.surface);
+    if (counts.size < 2 || onlyFirstLetterDiffers([...counts.keys()])) return [];
+    const [first] = counts;
+    if (first === undefined) return [];
+    const usual = [...counts].reduce((best, entry) => (entry[1].length > best[1].length ? entry : best), first)[0];
+    return group.filter((label) => label.surface !== usual).map((label) => ({ label, usual }));
+  });
+};

package/src/undefined-call.ts

@@ -0,0 +1,65 @@
+// A function called in a code example that the page never defines, where the page documents one whose name it extends:
+// wrapText( on a page about wrap, wrapLines( after import { wrap }. Pure; reads the Markdown source. The global functions
+// of programming languages (parseInt, setTimeout) come from a lexicon, so a page about parse may call parseInt.
+import { codeFences } from "./detectors/code-fences.ts";
+
+/** A call to a name the page does not define, where it is written, and the documented name it is likely a slip of. */
+export type UndefinedCall = { readonly name: string; readonly offset: number; readonly documented: string };
+
+const CALL = /(?<![\w$.])([A-Za-z_$][\w$]*)[ \t]*\(/gu;
+const WORD = /[A-Za-z_$][\w$]*/gu;
+const LEADING_WORD = /^[A-Za-z_$][\w$]*/u;
+/** import { wrap, type Options, measure as m } from "wrapkit" (JavaScript) and from wrapkit import wrap, measure (Python). */
+const IMPORT_BRACES = /\bimport[ \t]*\{([^}]*)\}/gu;
+const FROM_IMPORT = /\bfrom[ \t]+[\w.]+[ \t]+import[ \t]+([\w, \t]+)/gu;
+const TYPE_MODIFIER = /^type[ \t]+/u;
+/** A name right after one of these is being declared, not called: function wrapText(, def wrap_text(. */
+const DECLARING = /\b(?:function\*?|def|fn|func|class|new)[ \t]+$/u;
+/** Where a line comment starts: a call after it is commented out. */
+const LINE_COMMENT = /\/\/|(?:^|[ \t])#/u;
+/** The shortest documented name a call is compared with: shorter ones (id, get) are prefixes of too many names. */
+const MIN_DOCUMENTED = 4;
+
+/** Each specifier's own name: `type Options` is Options, `measure as m` is measure. */
+const specifiers = (list: string): string[] =>
+  list.split(",").flatMap((specifier) => LEADING_WORD.exec(specifier.trim().replace(TYPE_MODIFIER, ""))?.[0] ?? []);
+
+const importedNames = (source: string): string[] =>
+  [...source.matchAll(IMPORT_BRACES), ...source.matchAll(FROM_IMPORT)].flatMap((match) => specifiers(match[1] ?? ""));
+
+/** Names the page documents: the first word of a heading (## wrap, ### `wrap()`) and the names it imports. */
+const documentedNames = (source: string, headings: readonly string[]): Set<string> => {
+  const fromHeadings = headings.flatMap((heading) => LEADING_WORD.exec(heading.replace(/[`*]/gu, "").trim())?.[0] ?? []);
+  return new Set([...fromHeadings, ...importedNames(source)].filter((name) => name.length >= MIN_DOCUMENTED));
+};
+
+const countWords = (source: string): Map<string, number> =>
+  [...source.matchAll(WORD)].reduce((counts, match) => counts.set(match[0], (counts.get(match[0]) ?? 0) + 1), new Map<string, number>());
+
+/** Whether the call at `at` in `code` is declared there or commented out. */
+const isDeclaredOrCommented = (code: string, at: number): boolean => {
+  const lineStart = code.lastIndexOf("\n", at - 1) + 1;
+  const before = code.slice(lineStart, at);
+  return DECLARING.test(before) || LINE_COMMENT.test(before);
+};
+
+/**
+ * Every call in a code block to a name written nowhere else on the page, when a documented name is its stem
+ * (wrap → wrapText). A name used twice (defined and called, or called twice) is the example's own. headings are the page's
+ * Markdown headings; globals the language functions every page may call.
+ */
+export const undefinedCalls = (source: string, headings: readonly string[], globals: readonly string[] = []): UndefinedCall[] => {
+  const documented = documentedNames(source, headings);
+  if (documented.size === 0) return [];
+  const counts = countWords(source);
+  const known = new Set([...documented, ...globals]);
+  return codeFences(source).flatMap((fence) => {
+    const code = source.slice(fence.start, fence.end);
+    return [...code.matchAll(CALL)].flatMap((match) => {
+      const name = match[1] ?? "";
+      const stem = [...documented].find((candidate) => name !== candidate && name.startsWith(candidate));
+      if (stem === undefined || known.has(name) || (counts.get(name) ?? 0) > 1 || isDeclaredOrCommented(code, match.index)) return [];
+      return [{ name, offset: fence.start + match.index, documented: stem }];
+    });
+  });
+};

package/src/unnamed-speaker.ts

@@ -0,0 +1,224 @@
+// A quotation whose speaker, in the words right beside it, is a role and not a name (業界のアナリストは「…」と述べた,
+// "…," said an analyst). The words come from the language's word lists: unnamed-speaker (roles, what may follow a role,
+// titles, words pointing back, the quoting particle) and quote-attribution (said, according to, と述べ). Pure.
+import { QUOTATION_MARKS, quotedSpans } from "./quoted-span.ts";
+import type { LexiconEntry, Span } from "./plugin.ts";
+
+export type SpeakerSentence = { readonly start: number; readonly text: string };
+
+export type UnnamedSpeakerQuote = { readonly offset: number; readonly quote: string; readonly speaker: string };
+
+/** The word list unnamed-speaker, by group, and quote-attribution with the list's own cues (group cue), longest first. */
+export type SpeakerWords = {
+  readonly roles: readonly string[];
+  readonly afterRole: readonly string[];
+  readonly honorifics: readonly string[];
+  readonly anaphors: readonly string[];
+  readonly afterQuote: readonly string[];
+  readonly cues: readonly LexiconEntry[];
+};
+
+export const speakerWords = (speaker: readonly LexiconEntry[], cues: readonly LexiconEntry[]): SpeakerWords => {
+  const group = (name: string): string[] => speaker.filter((entry) => entry.group === name && entry.pattern !== "").map((entry) => entry.pattern);
+  return {
+    roles: group("role"),
+    afterRole: group("after-role"),
+    honorifics: group("honorific"),
+    anaphors: group("anaphor"),
+    afterQuote: group("after-quote"),
+    cues: [...cues, ...speaker.filter((entry) => entry.group === "cue")]
+      .filter((cue) => cue.pattern !== "")
+      .toSorted((left, right) => right.pattern.length - left.pattern.length),
+  };
+};
+
+/** Shorter than this, a quotation is a term or a label (「保存」, "Save"), not someone's words. */
+const MIN_QUOTE_CHARS = 10;
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const UPPER_START = /^\p{Lu}/u;
+const LOWER_START = /^\p{Ll}/u;
+const WORD = /[\p{L}\p{N}'’-]+/gu;
+/** Words, and the commas between them: a comma ends a run of capitalised words (an analyst at Acme, Hanako Mori). */
+const WORD_OR_COMMA = /[\p{L}\p{N}'’-]+|[,，]/gu;
+/** A Japanese title is not one when a kanji follows it (氏名, 様々). */
+const JOINED_KANJI = /^[\p{Script=Han}々]/u;
+/** How far from the quotation the speaker is looked for, on each side: keeps a long sentence of many quotations linear. */
+const SPEAKER_REACH = 200;
+/** Where the clause holding the speaker before a quotation starts: after these marks. */
+const CLAUSE_MARKS_BEFORE = /[。．！？!?;；「」『』“”"、，]/u;
+/** Where the speaker's phrase after a quotation ends. A comma does not end it in English (said Hanako Mori, an analyst). */
+const CLAUSE_MARKS_AFTER = /[。．！？.!?;；「」『』“”"]/u;
+/** Where a phrase after the quoting particle (「…」と業界関係者は話す) ends. */
+const CLAUSE_MARKS_PARTICLE = /[。．！？.!?;；「」『』“”"、，]/u;
+/** Where a speaker standing before its cue ("…," an analyst said) must not reach past. */
+const CLAUSE_MARKS_INNER = /[,，、。．！？.!?;；:：]/u;
+/** Spaces and marks that join a speaker to a quotation or a cue, and are not part of either. */
+const GLUE = /[\s,，、:：—–-]/u;
+const PHRASE_END = /^[,，、。．.;；:：)）]/u;
+
+/** A Latin word is matched whole and without case; a Japanese one as written, inside any text. */
+const matchesAt = (text: string, at: number, word: string): boolean => {
+  if (!LATIN.test(word)) return text.startsWith(word, at);
+  return (
+    text.slice(at, at + word.length).toLowerCase() === word.toLowerCase() && !LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + word.length))
+  );
+};
+
+const positionsOf = (text: string, word: string): number[] =>
+  word === "" ? [] : [...Array(Math.max(0, text.length - word.length + 1)).keys()].filter((at) => matchesAt(text, at, word));
+
+const startsWithWord = (text: string, word: string): boolean => matchesAt(text, 0, word);
+
+const endsWithWord = (text: string, word: string): boolean => text.length >= word.length && matchesAt(text, text.length - word.length, word);
+
+const afterLast = (text: string, marks: RegExp): string => {
+  const cut = [...text].reduce((last, char, index) => (marks.test(char) ? index : last), -1);
+  return [...text].slice(cut + 1).join("");
+};
+
+const beforeFirst = (text: string, marks: RegExp): string => {
+  const at = [...text].findIndex((char) => marks.test(char));
+  return at < 0 ? text : [...text].slice(0, at).join("");
+};
+
+/** The text without glue at either end. */
+const clean = (text: string): string => {
+  const chars = [...text];
+  const first = chars.findIndex((char) => !GLUE.test(char));
+  return first < 0 ? "" : chars.slice(first, chars.findLastIndex((char) => !GLUE.test(char)) + 1).join("");
+};
+
+/** leavesSpeakerBefore: after the quotation, whether the speaker may still be the one before it (「…」と述べた), not one after it (said X). */
+type Side = { readonly speaker: string; readonly attributed: boolean; readonly leavesSpeakerBefore?: boolean };
+
+/** The clause before the quotation: the speaker, with a cue at its end (An analyst said, 関係者によれば) or before it (according to). */
+const speakerBefore = (before: string, words: SpeakerWords): Side => {
+  const clause = clean(afterLast(clean(before), CLAUSE_MARKS_BEFORE));
+  const cues = words.cues.filter((cue) => cue.position !== "after");
+  const ending = cues.find((cue) => endsWithWord(clause, cue.pattern));
+  if (ending !== undefined) return { speaker: clean(clause.slice(0, clause.length - ending.pattern.length)), attributed: true };
+  const leads = cues
+    .filter((cue) => cue.position === "before")
+    .flatMap((cue) => positionsOf(clause, cue.pattern).map((at) => at + cue.pattern.length))
+    .toSorted((left, right) => right - left);
+  const lead = leads[0];
+  if (lead !== undefined) return { speaker: clean(clause.slice(lead)), attributed: true };
+  return { speaker: clause, attributed: false };
+};
+
+/** The words after the quotation: a quoting particle (「…」と業界関係者は), a cue then the speaker (said an analyst), or the speaker then a cue. */
+const speakerAfter = (after: string, words: SpeakerWords): Side => {
+  const rest = clean(after);
+  const particle = words.afterQuote.find((word) => startsWithWord(rest, word));
+  if (particle !== undefined)
+    return { speaker: clean(beforeFirst(clean(rest.slice(particle.length)), CLAUSE_MARKS_PARTICLE)), attributed: true, leavesSpeakerBefore: true };
+  const cues = words.cues.filter((cue) => cue.position !== "before");
+  const leading = cues.find((cue) => startsWithWord(rest, cue.pattern));
+  if (leading !== undefined) {
+    const speaker = clean(beforeFirst(rest.slice(leading.pattern.length), CLAUSE_MARKS_AFTER));
+    return { speaker, attributed: true, leavesSpeakerBefore: speaker === "" };
+  }
+  const clause = beforeFirst(rest, CLAUSE_MARKS_INNER);
+  const cueAt = cues.flatMap((cue) => positionsOf(clause, cue.pattern)).toSorted((left, right) => left - right)[0];
+  if (cueAt !== undefined) return { speaker: clean(clause.slice(0, cueAt)), attributed: true, leavesSpeakerBefore: cueAt === 0 };
+  return { speaker: "", attributed: false };
+};
+
+const isCapitalised = (word: string | undefined): boolean => word !== undefined && UPPER_START.test(word);
+
+const isRoleWord = (word: string | undefined, words: SpeakerWords): boolean =>
+  word !== undefined && words.roles.some((role) => LATIN.test(role) && role.toLowerCase() === word.toLowerCase());
+
+const isAfterRoleWord = (word: string | undefined, words: SpeakerWords): boolean =>
+  word !== undefined && words.afterRole.some((entry) => entry.toLowerCase() === word.toLowerCase());
+
+/**
+ * A run of capitalised words that is a person's name (Hanako Mori, analyst Hanako Mori). Not one: a run after a word like
+ * "at" (an analyst at Minato Research), a run right before a role (an Acme spokesperson), or, when the phrase opens the
+ * clause, its first word alone ("An analyst", "Experts"). After a cue it is a name: said Mori, an analyst.
+ */
+const holdsCapitalisedName = (phrase: string, words: SpeakerWords, opensSentence: boolean): boolean => {
+  const tokens = [...phrase.matchAll(WORD_OR_COMMA)].map((match) => match[0]);
+  return tokens.some((token, index) => {
+    if (!isCapitalised(token) || isCapitalised(tokens[index - 1])) return false;
+    const runEnd = tokens.findIndex((later, at) => at > index && !isCapitalised(later));
+    const end = runEnd < 0 ? tokens.length : runEnd;
+    if (isAfterRoleWord(tokens[index - 1], words) || isRoleWord(tokens[end], words)) return false;
+    const next = tokens[1];
+    return !(opensSentence && index === 0 && end === 1 && (next === undefined || LOWER_START.test(next)));
+  });
+};
+
+const holdsTitle = (phrase: string, title: string): boolean =>
+  positionsOf(phrase, title).some((at) => LATIN.test(title) || !JOINED_KANJI.test(phrase.slice(at + title.length)));
+
+const isNamed = (phrase: string, words: SpeakerWords, opensSentence: boolean): boolean =>
+  words.honorifics.some((title) => holdsTitle(phrase, title)) || holdsCapitalisedName(phrase, words, opensSentence);
+
+const lastWord = (text: string): string => [...text.matchAll(WORD)].map((match) => match[0]).at(-1) ?? "";
+
+/** Whether the role at this place is the head of the phrase: nothing after it, or only a word like は or "at". */
+const headsPhrase = (phrase: string, at: number, role: string, words: SpeakerWords): boolean => {
+  const after = phrase.slice(at + role.length).trimStart();
+  return after === "" || PHRASE_END.test(after) || words.afterRole.some((word) => startsWithWord(after, word));
+};
+
+const pointsBack = (phrase: string, at: number, words: SpeakerWords): boolean => {
+  const before = phrase.slice(0, at).trimEnd();
+  return words.anaphors.some((word) => (LATIN.test(word) ? lastWord(before).toLowerCase() === word.toLowerCase() : before.endsWith(word)));
+};
+
+/**
+ * The phrase as the message shows it, when a role heads it and does not point back at someone named before (同アナリスト,
+ * the analyst). A Japanese phrase is shown up to its role (業界関係者は話す as 業界関係者); an English one whole.
+ */
+const unnamedRoleIn = (phrase: string, words: SpeakerWords): string | undefined => {
+  const heads = words.roles.flatMap((role) =>
+    positionsOf(phrase, role)
+      .filter((at) => headsPhrase(phrase, at, role, words) && !pointsBack(phrase, at, words))
+      .map((at) => (LATIN.test(role) ? phrase : phrase.slice(0, at + role.length))),
+  );
+  return heads[0];
+};
+
+type Phrase = { readonly text: string; readonly opensSentence: boolean };
+
+/** The phrases that may be the speaker: the attributed side's, and the one before when a cue after leaves the speaker there. */
+const speakerPhrases = (before: Side, after: Side, beforeOpens: boolean): Phrase[] => {
+  const useBefore = before.attributed || (after.attributed && after.leavesSpeakerBefore === true);
+  return [
+    ...(useBefore ? [{ text: before.speaker, opensSentence: beforeOpens }] : []),
+    ...(after.attributed ? [{ text: after.speaker, opensSentence: false }] : []),
+  ].filter((phrase) => phrase.text !== "");
+};
+
+/** The phrase that gives this quotation to a role and to no name, if any. */
+const unnamedSpeakerOf = (text: string, span: Span, words: SpeakerWords): string | undefined => {
+  const reach = Math.max(0, span.start - 1 - SPEAKER_REACH);
+  const before = speakerBefore(text.slice(reach, span.start - 1), words);
+  const after = speakerAfter(text.slice(span.end + 1, span.end + 1 + SPEAKER_REACH), words);
+  const phrases = speakerPhrases(
+    before,
+    after,
+    reach === 0 &&
+      text
+        .slice(0, span.start - 1)
+        .trim()
+        .startsWith(before.speaker),
+  );
+  if (phrases.some((phrase) => isNamed(phrase.text, words, phrase.opensSentence))) return undefined;
+  return phrases.map((phrase) => unnamedRoleIn(phrase.text, words)).find((speaker) => speaker !== undefined);
+};
+
+/** Each quotation in the sentence given to a role with no name. */
+export const unnamedSpeakerQuotes = (sentence: SpeakerSentence, words: SpeakerWords): UnnamedSpeakerQuote[] => {
+  if (words.roles.length === 0) return [];
+  return quotedSpans(sentence.text, QUOTATION_MARKS).flatMap((span) => {
+    const quote = clean(sentence.text.slice(span.start, span.end));
+    if ([...quote].length < MIN_QUOTE_CHARS) return [];
+    const speaker = unnamedSpeakerOf(sentence.text, span, words);
+    return speaker === undefined ? [] : [{ offset: sentence.start + span.start, quote, speaker }];
+  });
+};