chaffjs 0.28.0 → 0.30.0

package/src/parameter-table.ts

@@ -0,0 +1,208 @@
+// A function's signature in a code block against the parameter table written under it: a row naming a parameter the
+// signature does not take, or a parameter of the signature the table leaves out. Pure; reads the Markdown source. The
+// header words that make a table a parameter table (Parameter, 引数) come from the language's lexicon.
+
+/** A name, where it is written, and the function it belongs to. */
+export type ParameterSlip = { readonly name: string; readonly offset: number; readonly fn: string; readonly side: "table" | "signature" };
+
+type Line = { readonly text: string; readonly start: number };
+type Signature = { readonly fn: string; readonly params: readonly { readonly name: string; readonly offset: number }[] };
+
+const FENCE = /^ {0,3}(`{3,}|~{3,})/u;
+const HEADING = /^ {0,3}#{1,6}[ \t]/u;
+const TABLE_ROW = /^[ \t]{0,3}\|/u;
+const DELIMITER_ROW = /^[ \t]{0,3}\|?[ \t]*:?-{3,}/u;
+
+const MODIFIERS = /^[ \t]*(?:(?:export|declare|async)[ \t]+)*/u;
+const KEYWORD = /^(?:function\*?|def|fn|func)[ \t]+/u;
+const BINDING = /^(?:const|let|var)[ \t]+/u;
+/** After a bound name, up to the arrow function's list: `: Wrap = async (`. */
+const ARROW_START = /^[^=]*=[ \t]*(?:async[ \t]*)?\(/u;
+/** After an arrow function's list: an optional return type, then =>. */
+const ARROW_END = /^[ \t]*(?::[^=]*)?=>/u;
+const RETURN_TYPE = /^[ \t]*(?::|->)/u;
+const GENERICS = /^[ \t]*<[^<>()]*>/u;
+
+const IDENTIFIER = /^[A-Za-z_$][\w$]*/u;
+/** What may stand before a parameter's name: a spread (...rest, *args, **kwargs) or a Rust borrow (&self, &mut self, mut x). */
+const SPREAD = /^(?:\.\.\.|\*{1,2}|&(?:mut[ \t]+)?|mut[ \t]+)/u;
+/** The receiver a method declares first, which a call does not pass. */
+const RECEIVERS: ReadonlySet<string> = new Set(["self", "cls", "this"]);
+const OPENERS = "([{<";
+const CLOSERS = ")]}>";
+const ARROW_HEADS = "=-";
+
+const linesOf = (source: string): Line[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1), start }));
+};
+
+/** The parameters' text split at the commas outside brackets, with where each starts. */
+const splitParams = (text: string): { readonly text: string; readonly from: number }[] => {
+  const parts: { text: string; from: number }[] = [];
+  const state = { depth: 0, from: 0 };
+  [...text].forEach((char, index) => {
+    if (OPENERS.includes(char)) state.depth += 1;
+    // The > of an arrow (=> in a callback's type, -> in a return type) closes no bracket.
+    if (CLOSERS.includes(char) && !(char === ">" && ARROW_HEADS.includes(text[index - 1] ?? " "))) state.depth -= 1;
+    if (char !== "," || state.depth !== 0) return;
+    parts.push({ text: text.slice(state.from, index), from: state.from });
+    state.from = index + 1;
+  });
+  parts.push({ text: text.slice(state.from), from: state.from });
+  return parts.filter((part) => part.text.trim() !== "");
+};
+
+const skipSpaces = (text: string, at: number): number => at + (text.slice(at).length - text.slice(at).trimStart().length);
+
+/** The index of the ) that closes the ( at `open`, or -1. */
+const closingParen = (text: string, open: number): number => {
+  const state = { depth: 0, at: -1 };
+  Array.from(text.slice(open)).some((char, index) => {
+    if (char === "(") state.depth += 1;
+    if (char === ")") state.depth -= 1;
+    if (state.depth === 0) state.at = open + index;
+    return state.depth === 0;
+  });
+  return state.at;
+};
+
+type Declared = { readonly fn: string; readonly params: string; readonly paramsAt: number };
+
+/** The parameter list that opens at `open`, if it closes and `isDeclaration` holds for the text after it. */
+const listAt = (line: string, fn: string, open: number, isDeclaration: (after: string) => boolean): Declared | undefined => {
+  const close = line[open] === "(" ? closingParen(line, open) : -1;
+  return close === -1 || !isDeclaration(line.slice(close + 1)) ? undefined : { fn, params: line.slice(open + 1, close), paramsAt: open + 1 };
+};
+
+/** An arrow function bound to a name: `const wrap = (text: string): string[] =>`. */
+const arrowOf = (line: string, at: number): Declared | undefined => {
+  const binding = BINDING.exec(line.slice(at));
+  const fn = binding === null ? undefined : IDENTIFIER.exec(line.slice(at + binding[0].length))?.[0];
+  if (binding === null || fn === undefined) return undefined;
+  const afterName = at + binding[0].length + fn.length;
+  const start = ARROW_START.exec(line.slice(afterName));
+  return start === null ? undefined : listAt(line, fn, afterName + start[0].length - 1, (after) => ARROW_END.test(after));
+};
+
+/**
+ * A declaration: a keyword before the name (function, def, fn, func with a Go receiver or without) or a return type after
+ * the list (`): number`, `) -> int`). A call (`wrap(text, 10);`) has neither.
+ */
+const functionOf = (line: string, at: number): Declared | undefined => {
+  const keyword = KEYWORD.exec(line.slice(at))?.[0];
+  const afterKeyword = at + (keyword?.length ?? 0);
+  const receiverEnd = keyword?.startsWith("func") === true && line[afterKeyword] === "(" ? closingParen(line, afterKeyword) : -1;
+  const nameAt = receiverEnd === -1 ? afterKeyword : skipSpaces(line, receiverEnd + 1);
+  const fn = IDENTIFIER.exec(line.slice(nameAt))?.[0];
+  if (fn === undefined) return undefined;
+  const afterName = nameAt + fn.length;
+  const generics = GENERICS.exec(line.slice(afterName))?.[0] ?? "";
+  const open = skipSpaces(line, afterName + generics.length);
+  return listAt(line, fn, open, (after) => keyword !== undefined || RETURN_TYPE.test(after));
+};
+
+const declarationOf = (line: string): Declared | undefined => {
+  const at = MODIFIERS.exec(line)?.[0].length ?? 0;
+  return arrowOf(line, at) ?? functionOf(line, at);
+};
+
+/** The signature a line declares; undefined for a call, or for a parameter that is not a plain name (a destructured one). */
+export const signatureOf = (line: string, offset = 0): Signature | undefined => {
+  const declared = declarationOf(line);
+  if (declared === undefined) return undefined;
+  const { paramsAt } = declared;
+  const params = splitParams(declared.params).map((part) => {
+    const lead = part.text.length - part.text.trimStart().length;
+    const spread = SPREAD.exec(part.text.trimStart())?.[0] ?? "";
+    const name = IDENTIFIER.exec(part.text.trimStart().slice(spread.length))?.[0];
+    return { name, offset: offset + paramsAt + part.from + lead + spread.length };
+  });
+  if (params.some((param) => param.name === undefined)) return undefined;
+  return {
+    fn: declared.fn,
+    params: params.flatMap((param) => (param.name === undefined || RECEIVERS.has(param.name) ? [] : [{ name: param.name, offset: param.offset }])),
+  };
+};
+
+const cellsOf = (text: string): { readonly text: string; readonly from: number }[] => {
+  const bounds = [-1, ...[...text.matchAll(/(?<!\\)\|/gu)].map((match) => match.index), text.length];
+  const cells = bounds.slice(1).map((end, index) => ({ text: text.slice((bounds[index] ?? -1) + 1, end), from: (bounds[index] ?? -1) + 1 }));
+  return cells.slice(cells[0]?.text.trim() === "" ? 1 : 0);
+};
+
+const WRAPPING_MARKS = "`*_";
+
+/** A cell's text without the code and emphasis marks around it (`width`, **width**). */
+const unwrap = (text: string): string => {
+  const chars = [...text.trim()];
+  const from = chars.findIndex((char) => !WRAPPING_MARKS.includes(char));
+  return from === -1 ? "" : chars.slice(from, chars.findLastIndex((char) => !WRAPPING_MARKS.includes(char)) + 1).join("");
+};
+
+/** A parameter row's name: `options.prefix` is a field of options, `width?` the parameter width. */
+const rowName = (line: Line): { readonly name: string; readonly offset: number } | undefined => {
+  const cell = cellsOf(line.text)[0];
+  if (cell === undefined) return undefined;
+  const bare = unwrap(cell.text);
+  const name = IDENTIFIER.exec(bare.replace(SPREAD, ""))?.[0];
+  return name === undefined ? undefined : { name, offset: line.start + cell.from + cell.text.indexOf(bare) };
+};
+
+const isHeaderOf = (line: Line, headers: ReadonlySet<string>): boolean => headers.has(unwrap(cellsOf(line.text)[0]?.text ?? "").toLowerCase());
+
+/** The rows of the table whose header is at `index`, up to the first line that is not a row. */
+const rowsFrom = (lines: readonly Line[], index: number): Line[] => {
+  const end = lines.findIndex((line, at) => at > index + 1 && !TABLE_ROW.test(line.text));
+  return lines.slice(index + 2, end === -1 ? lines.length : end);
+};
+
+const compare = (signature: Signature & { readonly line: number }, rows: readonly Line[]): ParameterSlip[] => {
+  const named = rows.flatMap((row) => rowName(row) ?? []);
+  const inTable = new Set(named.map((row) => row.name));
+  const inSignature = new Set(signature.params.map((param) => param.name));
+  return [
+    ...signature.params.filter((param) => !inTable.has(param.name)).map((param) => ({ ...param, fn: signature.fn, side: "signature" as const })),
+    ...named.filter((row) => !inSignature.has(row.name)).map((row) => ({ ...row, fn: signature.fn, side: "table" as const })),
+  ].toSorted((left, right) => left.offset - right.offset);
+};
+
+type Walk = { fence: string | undefined; signatures: (Signature & { line: number })[]; pending: (Signature & { line: number }) | undefined };
+
+/**
+ * Every parameter table that follows a code block declaring exactly one function, before the next heading or code
+ * block, compared with that function's signature. headers are the lowercase words a parameter table's first header has.
+ */
+/** A line inside a code block: a declaration is collected, and the closing fence leaves the block's one signature pending. */
+const inBlock = (walk: Walk, line: Line, index: number, fence: string | undefined): void => {
+  const open = walk.fence ?? "";
+  if (fence !== undefined && fence[0] === open[0] && fence.length >= open.length) {
+    walk.pending = walk.signatures.length === 1 ? walk.signatures[0] : undefined;
+    walk.fence = undefined;
+    return;
+  }
+  const signature = signatureOf(line.text, line.start);
+  if (signature !== undefined) walk.signatures.push({ ...signature, line: index });
+};
+
+export const parameterSlips = (source: string, headers: ReadonlySet<string>): ParameterSlip[] => {
+  const lines = linesOf(source);
+  const walk: Walk = { fence: undefined, signatures: [], pending: undefined };
+  return lines.flatMap((line, index) => {
+    const fence = FENCE.exec(line.text)?.[1];
+    if (walk.fence !== undefined) {
+      inBlock(walk, line, index, fence);
+      return [];
+    }
+    if (fence !== undefined || HEADING.test(line.text)) {
+      walk.fence = fence;
+      walk.signatures = [];
+      walk.pending = undefined;
+      return [];
+    }
+    const pending = walk.pending;
+    if (pending === undefined || !TABLE_ROW.test(line.text) || !DELIMITER_ROW.test(lines[index + 1]?.text ?? "")) return [];
+    walk.pending = undefined;
+    return isHeaderOf(line, headers) ? compare(pending, rowsFrom(lines, index)) : [];
+  });
+};

package/src/phone-numbers.ts

@@ -0,0 +1,98 @@
+// One phone number written two ways in a document: the same digits with two neighbours swapped (0120-123-456 and
+// 0120-123-465), both after a label of the same kind. Pure: reads the document's text; the labels (電話, Phone, FAX) come
+// from the language's phone-label lexicon, grouped by what they label, so a phone number and a fax number are never compared.
+import type { LexiconEntry } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+/** A number as written, where it is, its digits and the group of the nearest label before it on its line. */
+export type PhoneNumber = { readonly offset: number; readonly written: string; readonly digits: string; readonly label: string };
+
+/** A number whose digits are another's with two neighbours swapped, and that other number. */
+export type PhoneVariant = { readonly number: PhoneNumber; readonly other: PhoneNumber };
+
+const MIN_DIGITS = 9;
+const MAX_DIGITS = 13;
+/** What joins two groups of digits: a hyphen, a closing bracket (with a space or hyphen after it) or an opening one. */
+const GROUP_JOIN = String.raw`(?:[-‐−]|[)）][ \-‐−]?|[(（])`;
+/** Not part of a longer number, a date's or an amount's digits. */
+const NUMBER_EDGE_BEFORE = String.raw`(?<![\d,.\-‐−])`;
+const NUMBER_EDGE_AFTER = String.raw`(?![\d\-‐−]|[.,]\d)`;
+const COUNTRY_CODE = String.raw`(?:\+\d{1,3}[ -]?)?`;
+/** Groups of digits joined by hyphens or brackets (03-1234-5678, 03（1234）5678, (555) 123-4567, +81-3-1234-5678). */
+const NUMBER_SHAPE = new RegExp(String.raw`${NUMBER_EDGE_BEFORE}${COUNTRY_CODE}[(（]?\d{1,5}(?:${GROUP_JOIN}\d{1,5}){1,3}${NUMBER_EDGE_AFTER}`, "gu");
+const NOT_DIGIT = /\D/gu;
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+/** How far before a number its label may end: 「電話でのお問合せは、」, "by phone, call". */
+const MAX_LABEL_GAP = 15;
+const URL = /\b(?:https?:\/\/|www\.)\S+/giu;
+
+/** Where a label last occurs in a line's text before a number; a Latin label only as a whole word (tel, not hotel). */
+const lastPlace = (before: string, label: string): number => {
+  const lowered = label.toLowerCase();
+  const places = [...before.matchAll(new RegExp(escapeRegExp(lowered), "gu"))].map((match) => match.index);
+  const whole = LATIN_START.test(label) ? places.filter((at) => !LETTER.test(before[at - 1] ?? "") && !LETTER.test(before[at + lowered.length] ?? "")) : places;
+  return whole.at(-1) ?? -1;
+};
+
+/** The group of the label ending nearest before a number on its line, the longest when two end together (携帯電話 over 電話). */
+const labelBefore = (text: string, offset: number, labels: readonly LexiconEntry[]): string | undefined => {
+  const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
+  const before = text.slice(lineStart, offset).toLowerCase();
+  const nearest = labels
+    .map((entry) => {
+      const at = lastPlace(before, entry.pattern);
+      return { group: entry.group ?? entry.pattern, at, end: at + entry.pattern.length };
+    })
+    .filter((hit) => hit.at >= 0 && before.length - hit.end <= MAX_LABEL_GAP)
+    .toSorted((a, b) => b.end - a.end || a.at - b.at)[0];
+  return nearest?.group;
+};
+
+/** URLs covered with spaces, so neither a path segment (/call/) nor an id in one is read. Offsets stay the same. */
+const withoutUrls = (text: string): string => text.replaceAll(URL, (url) => " ".repeat(url.length));
+
+/** The phone numbers of a text that have a label shortly before them on their line; unlabelled digits and URLs are not read. */
+export const labelledPhoneNumbers = (source: string, labels: readonly LexiconEntry[]): PhoneNumber[] => {
+  const text = withoutUrls(source);
+  return [...text.matchAll(NUMBER_SHAPE)].flatMap((match) => {
+    const digits = match[0].replaceAll(NOT_DIGIT, "");
+    if (digits.length < MIN_DIGITS || digits.length > MAX_DIGITS) return [];
+    const label = labelBefore(text, match.index, labels);
+    return label === undefined ? [] : [{ offset: match.index, written: match[0].trim(), digits, label }];
+  });
+};
+
+/** Whether two digit strings are the same but for one pair of neighbours swapped. */
+export const swapsNeighbours = (a: string, b: string): boolean => {
+  if (a.length !== b.length || a === b) return false;
+  const differ = [...a].flatMap((digit, index) => (digit === b[index] ? [] : [index]));
+  const [first, second] = differ;
+  return differ.length === 2 && first !== undefined && second === first + 1 && a[first] === b[second] && a[second] === b[first];
+};
+
+const keyOf = (number: PhoneNumber): string => `${number.label}\u0000${number.digits}`;
+
+/**
+ * Every writing of a number that is another number of the same label with two neighbours swapped: of the two, the one
+ * written fewer times, or the one first written later when both are written as often. Each comes with the other number.
+ */
+export const phoneVariants = (numbers: readonly PhoneNumber[]): PhoneVariant[] => {
+  const writings = numbers.reduce((byKey, number) => byKey.set(keyOf(number), [...(byKey.get(keyOf(number)) ?? []), number]), new Map<string, PhoneNumber[]>());
+  const timesOf = (number: PhoneNumber): number => writings.get(keyOf(number))?.length ?? 0;
+  const firsts = [...writings.values()].flatMap((group) => group.slice(0, 1));
+  const minorityOf = (a: PhoneNumber, b: PhoneNumber): PhoneNumber => {
+    if (timesOf(a) !== timesOf(b)) return timesOf(a) < timesOf(b) ? a : b;
+    return a.offset > b.offset ? a : b;
+  };
+  return firsts
+    .flatMap((first, index) =>
+      firsts.slice(index + 1).flatMap((second) => {
+        if (first.label !== second.label || !swapsNeighbours(first.digits, second.digits)) return [];
+        const minority = minorityOf(first, second);
+        const other = minority === first ? second : first;
+        return (writings.get(keyOf(minority)) ?? []).map((number) => ({ number, other }));
+      }),
+    )
+    .toSorted((a, b) => a.number.offset - b.number.offset);
+};

package/src/place-names.ts

@@ -0,0 +1,248 @@
+import { isNearWord, nameKey } from "./name-variants.ts";
+import { escapeRegExp } from "./orthography.ts";
+import { toKatakana } from "./kana-spelling.ts";
+
+// 場所の名前を、文書の中で二通りに書いた所（八重洲中央口 と 八重州中央口、11th Street と 11th St.、King's Cross と Kings Cross）。
+// 場所の名前は、場所を言う語（口、駅、センター、Street、Station）で終わる名前。場所の語は語彙表 place-word が言い、group が同じ語は
+// 同じ語の別の書き方（Street と St.、Center と Centre）。名前の部分は、場所の語のすぐ前の、名前に使う字の連なり。
+
+type Span = { readonly start: number; readonly end: number };
+
+export type PlaceWord = { readonly pattern: string; readonly group: string };
+
+/**
+ * surface は場所の語も含めた書いたまま。base は名前の部分、place は場所の語の組。reading は名前の部分の読み（読めなければ無い）。properAt は
+ * base の字のうち、品詞解析が固有名詞と読んだ語に入る字の位置（八重洲中央口 の 八・重・洲）。
+ */
+export type PlaceMention = {
+  readonly surface: string;
+  readonly offset: number;
+  readonly base: string;
+  readonly place: string;
+  readonly reading?: string | undefined;
+  readonly properAt: readonly number[];
+};
+
+/**
+ * 名前の現れの読み方。properWords は範囲に掛かる、品詞解析が固有名詞と読んだ語の範囲、isFunctionWord は名前の頭に立たない語（The、At）、readingOf は範囲の読み、joiners は
+ * 英字の名前の中に立つ小さい語（of）。
+ */
+export type PlaceReader = {
+  readonly properWords: (start: number, end: number) => readonly Span[];
+  readonly joiners: ReadonlySet<string>;
+  readonly isFunctionWord: (start: number, end: number) => boolean;
+  readonly readingOf: (start: number, end: number) => string | undefined;
+};
+
+/** spelling は記号・幅・大小だけ、place-word は場所の語の書き方、reading は読みが同じ、near は名前の一字違い。 */
+export type PlaceRelation = "spelling" | "place-word" | "reading" | "near";
+
+export type PlaceVariant = { readonly mention: PlaceMention; readonly usual: string; readonly kind: PlaceRelation };
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+/** 漢字・カタカナの名前に使う字。ひらがなは名前の外（の、で、にて）。 */
+const CJK_NAME = /[\p{Script=Katakana}\p{Script=Han}\p{Script=Latin}\p{N}ー・々]/u;
+const HIRAGANA = /\p{Script=Hiragana}/u;
+const JOINER = "・";
+/** かなだけの名前の前に立つもの。空白、行の頭、開き括弧。読点のあと（、この口）は文の続き。 */
+const KANA_NAME_OPENS = /^$|[\s（「『【([]/u;
+/** 英字の名前の一語。大文字で始まる語か、序数（11th）。 */
+const LATIN_NAME_WORD = /^(?:\p{Lu}[\p{L}'’&-]*|\d+(?:st|nd|rd|th))$/u;
+
+/** 場所の語が語の終わりに立つか。続く字が名前の字なら、長い語の一部（口座、Streetcar）。 */
+const endsWord = (source: string, end: number, latin: boolean): boolean => {
+  const next = source.charAt(end);
+  return latin ? !LETTER.test(next) : !CJK_NAME.test(next) || next === JOINER;
+};
+
+/** 名前を探す、場所の語の前の範囲（UTF-16 の単位）。 */
+const LOOKBACK = 40;
+
+/** end のすぐ前の、char の字の連なりの始まり。 */
+const runStart = (source: string, end: number, char: RegExp): number => {
+  const chars = Array.from(source.slice(Math.max(0, end - LOOKBACK), end));
+  return end - chars.slice(chars.findLastIndex((letter) => !char.test(letter)) + 1).join("").length;
+};
+
+/**
+ * 漢字・カタカナの名前: 場所の語の前の、名前に使う字の連なり。それが無く、空白や開き括弧のあとにひらがなだけが続くなら、かなで書いた
+ * 名前（博多駅 ちくし口）。語のあとのひらがな（東京駅の北口 の の）は名前の外。
+ */
+const cjkBaseBefore = (source: string, end: number): Span | undefined => {
+  const start = runStart(source, end, CJK_NAME);
+  const kanaStart = start === end ? runStart(source, end, HIRAGANA) : start;
+  const from = kanaStart < start && !KANA_NAME_OPENS.test(source.charAt(kanaStart - 1)) ? start : kanaStart;
+  const trimmed = source.startsWith(JOINER, from) ? from + 1 : from;
+  return trimmed < end ? { start: trimmed, end } : undefined;
+};
+
+/** 英字の名前の一語の前に、空白一つで続く語。 */
+const wordBefore = (source: string, at: number): Span | undefined => {
+  if (source.charAt(at - 1) !== " ") return undefined;
+  const from = Math.max(0, at - 1 - LOOKBACK);
+  const text = source.slice(from, at - 1);
+  const parts = text.split(/\s/u);
+  const word = parts.at(-1) ?? "";
+  if (word === "" || (from > 0 && parts.length === 1)) return undefined;
+  const start = from + text.length - word.length;
+  return { start, end: start + word.length };
+};
+
+/** 名前の前の、大文字で始まる短い略語（St. George Street の St.）。名前はそこから続くので、どこからが名前か分からない。 */
+const LEADING_ABBREVIATION = /^\p{Lu}\p{L}{0,2}\.$/u;
+
+/**
+ * 英字の名前: 場所の語の前の、空白一つでつながる大文字の語か序数の続き。名前の中の小さい語（University of Tokyo の of）は語彙表
+ * place-name-joiner が言う。頭の機能語（The、At）は外す。前に略語（St.）が立てば、名前の始まりが分からないので読まない。
+ */
+const latinBaseBefore = (source: string, end: number, reader: PlaceReader): Span | undefined => {
+  const words: Span[] = [];
+  const isNameWord = (span: Span | undefined): span is Span => span !== undefined && LATIN_NAME_WORD.test(source.slice(span.start, span.end));
+  const step = (at: number): Span | undefined => {
+    const word = wordBefore(source, at);
+    if (word === undefined) return undefined;
+    const joined = reader.joiners.has(source.slice(word.start, word.end)) && isNameWord(wordBefore(source, word.start));
+    if (!isNameWord(word) && !joined) return word;
+    words.unshift(word);
+    return step(word.start);
+  };
+  const stopper = step(end);
+  if (stopper !== undefined && LEADING_ABBREVIATION.test(source.slice(stopper.start, stopper.end))) return undefined;
+  const name = words.slice(
+    Math.max(
+      0,
+      words.findIndex((word) => !reader.isFunctionWord(word.start, word.end)),
+    ),
+  );
+  const [first, last] = [name[0], name.at(-1)];
+  return first === undefined || last === undefined || reader.isFunctionWord(first.start, first.end) ? undefined : { start: first.start, end: last.end };
+};
+
+/**
+ * base の字のうち、名前の部分の中で閉じる固有名詞の語に入る字の位置。場所の語まで続く固有名詞（北口、日比谷公園）は、名前でなく
+ * 出口や施設の呼び名として読まれたものなので数えない。
+ */
+const properIndexes = (source: string, base: Span, properWords: readonly Span[]): number[] => {
+  const inside = properWords.filter((word) => word.end <= base.end);
+  return Array.from(source.slice(base.start, base.end)).flatMap((_char, index, chars) => {
+    const at = base.start + chars.slice(0, index).join("").length;
+    return inside.some((word) => word.start <= at && at < word.end) ? [index] : [];
+  });
+};
+
+const mentionAt = (source: string, word: PlaceWord, at: number, reader: PlaceReader): PlaceMention | undefined => {
+  const latin = LATIN.test(word.pattern);
+  const end = at + word.pattern.length;
+  if (!endsWord(source, end, latin) || (latin && LETTER.test(source.charAt(at - 1)))) return undefined;
+  const base = latin ? latinBaseBefore(source, at, reader) : cjkBaseBefore(source, at);
+  if (base === undefined) return undefined;
+  return {
+    surface: source.slice(base.start, end),
+    offset: base.start,
+    base: source.slice(base.start, latin ? at - 1 : at),
+    place: word.group,
+    reading: latin ? undefined : reader.readingOf(base.start, at),
+    properAt: latin ? [] : properIndexes(source, base, reader.properWords(base.start, end)),
+  };
+};
+
+/** 文書の中の場所の名前の現れ。同じ所で終わる場所の語は長いほうを取る（中央口 と 口）。 */
+export const placeMentionsIn = (source: string, words: readonly PlaceWord[], reader: PlaceReader): PlaceMention[] => {
+  const ends = new Set<number>();
+  return words
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((word) =>
+      [...source.matchAll(new RegExp(escapeRegExp(word.pattern), "gu"))].flatMap((match) => {
+        const end = match.index + word.pattern.length;
+        if (ends.has(end)) return [];
+        const mention = mentionAt(source, word, match.index, reader);
+        if (mention !== undefined) ends.add(end);
+        return mention === undefined ? [] : [mention];
+      }),
+    )
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+const DIGIT = /\p{N}/u;
+
+/** 漢字・かなの名前の部分が一字だけ違い、その字が、多いほうで固有名詞の語に入る（八重洲 と 八重州）。数字や方角（北口 と 南口）は別の所。 */
+const isCjkSlip = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  const [slipChars, usualChars] = [[...slip.base], [...usual.base]];
+  if (slipChars.length !== usualChars.length) return false;
+  const differ = usualChars.flatMap((char, index) => (char === slipChars[index] ? [] : [index]));
+  const [at] = differ;
+  return differ.length === 1 && at !== undefined && usual.properAt.includes(at) && !DIGIT.test(usualChars[at] ?? "") && !DIGIT.test(slipChars[at] ?? "");
+};
+
+const latinWords = (base: string): string[] =>
+  base
+    .toLowerCase()
+    .replaceAll(/['’]/gu, "")
+    .split(/[\s-]+/u);
+
+/** 英字の名前の部分が、一語だけ一字違い（Union と Unoin）。 */
+const isLatinSlip = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  const [slipWords, usualWords] = [latinWords(slip.base), latinWords(usual.base)];
+  const differ = usualWords.flatMap((word, index) => (word === slipWords[index] ? [] : [index]));
+  const [at] = differ;
+  return slipWords.length === usualWords.length && differ.length === 1 && at !== undefined && isNearWord(slipWords[at] ?? "", usualWords[at] ?? "");
+};
+
+const HIRAGANA_ONLY = /^\p{Script=Hiragana}+$/u;
+
+/**
+ * ひらがなで書いた名前（ちくし）が、漢字で書いた名前（筑紫）の読みと同じか、一字だけ違う。解析器は地名の読みを一通りしか持たず
+ * （筑紫 を ツクシ と読む）、かなで書いた読み（チクシ）と一字ずれることがある。
+ */
+const isKanaSpellingOf = (slip: PlaceMention, usual: PlaceMention): boolean => {
+  if (!HIRAGANA_ONLY.test(slip.base) || usual.reading === undefined || HIRAGANA_ONLY.test(usual.base)) return false;
+  const [kana, reading] = [[...toKatakana(slip.base)], [...usual.reading]];
+  return kana.length === reading.length && kana.filter((char, index) => char !== reading[index]).length <= 1;
+};
+
+/** 一度だけ書いた形と、二度以上書いた形。読みの同じ別の所や一字違いの別の所もあるので、書き損じと見るのはこのときだけ。 */
+type Counted = { readonly mention: PlaceMention; readonly count: number };
+
+const isSlipOf = (slip: Counted, usual: Counted): boolean => slip.count === 1 && usual.count >= 2;
+
+/**
+ * 二つの書き方が、同じ所を二通りに書いたものか。場所の語の組が同じで、名前と語の全体が記号・幅・大小だけ違うか、場所の語の
+ * 書き方だけが違う（11th St. と 11th Street）か。名前の部分の読みが同じか、かなで書いた読み（筑紫口 と ちくし口）か、一字違い
+ * （八重洲 と 八重州）なのは、
+ * 少ないほうが一度だけ、多いほうが二度以上のときに限る。
+ */
+export const placeRelation = (slip: Counted, usual: Counted): PlaceRelation | undefined => {
+  const [left, right] = [slip.mention, usual.mention];
+  if (left.surface === right.surface || left.place !== right.place) return undefined;
+  if (nameKey(left.surface) === nameKey(right.surface)) return "spelling";
+  if (nameKey(left.base) === nameKey(right.base)) return "place-word";
+  if (!isSlipOf(slip, usual)) return undefined;
+  if ((left.reading !== undefined && left.reading === right.reading) || isKanaSpellingOf(left, right)) return "reading";
+  const latin = LATIN.test(left.base) && LATIN.test(right.base);
+  const slipped = latin ? isLatinSlip(left, right) : isCjkSlip(left, right);
+  return slipped ? "near" : undefined;
+};
+
+const talliesOf = (mentions: readonly PlaceMention[]): Counted[] => {
+  const tallies = new Map<string, Counted>();
+  mentions.forEach((mention) => {
+    const tally = tallies.get(mention.surface);
+    tallies.set(mention.surface, { mention: tally?.mention ?? mention, count: (tally?.count ?? 0) + 1 });
+  });
+  return [...tallies.values()];
+};
+
+/** 多いほうが先。同数なら先に書いたほう。 */
+const byUsage = (left: Counted, right: Counted): number => right.count - left.count || left.mention.offset - right.mention.offset;
+
+/** 同じ所の、少ないほうの書き方。同じ所と言える相手のうち一番多いものと比べる。書き方ごとに最初の現れを一つ。 */
+export const placeVariants = (mentions: readonly PlaceMention[]): PlaceVariant[] => {
+  const tallies = talliesOf(mentions);
+  return tallies.flatMap((tally) => {
+    const [usual] = tallies.filter((other) => other !== tally && placeRelation(tally, other) !== undefined).toSorted(byUsage);
+    if (usual === undefined || byUsage(usual, tally) > 0) return [];
+    const kind = placeRelation(tally, usual);
+    return kind === undefined ? [] : [{ mention: tally.mention, usual: usual.mention.surface, kind }];
+  });
+};

package/src/plugin.ts

@@ -275,6 +275,8 @@ export type DocumentProfile = {
    * inside の単位の行に、番号の後ろの本文が続くときだけ。
    */
   readonly unnumbered?: { readonly indent: string; readonly inside: string; readonly depth: number } | undefined;
+  /** 定義した語を括弧に入れて、語そのものを指す（「株主」とあるのは、"controller" has the same meaning）。定義し直しでも、括弧の付け忘れでもない。 */
+  readonly quoteMentionsTerm?: boolean | undefined;
 };
 
 /**
@@ -360,8 +362,13 @@ export type ProseDocument = {
   readonly markup?: Markup | undefined;
   /** adapter の綴りの辞書。持たない言語では無い。 */
   readonly dictionary?: (() => ReadonlySet<string>) | undefined;
+  /** 表の本体の升と、升ごとに解析した語（位置は source の上）。本文（prose）は表を覆うので、升の語は sentences に入らない。呼んだときに作る。 */
+  readonly tableCells?: (() => readonly TableCell[]) | undefined;
 };
 
+/** 表の升一つ。text は区切りの | のあいだの字のまま。tokens は升の字を adapter が解析した語で、解析しない adapter では無い。 */
+export type TableCell = Span & { readonly text: string; readonly tokens?: readonly Token[] };
+
 /** 見出し 1 つ。text は属性（`{#id}`）を外した言葉。 */
 export type MarkupHeading = { readonly depth: number; readonly text: string; readonly start: number; readonly end: number };
 
@@ -497,6 +504,8 @@ export type RuleDefinition = {
   /** 動かす言語。未指定は全言語。「ですます調」のように言語に固有の rule が使う。 */
   readonly languages: readonly string[] | undefined;
   readonly use_for: readonly string[];
+  /** Off unless chaff.yaml or its style gives the rule a level: a house style's own rule (a 公用文 spelling), wrong for other documents. */
+  readonly opt_in?: true;
   readonly severity: Severity;
   /** Options beyond the level (the direction and length for katakana-long-vowel). Most rules have none. */
   readonly options?: Readonly<Record<string, RuleOption>>;

package/src/prerequisite-order.ts

@@ -0,0 +1,39 @@
+// A prerequisite ("Before you begin, stop the service", 「作業を始める前に、」) written after the numbered steps of its own
+// section: the reader has done the steps by the time they read it. Pure; the openers come from the language's
+// prerequisite-opener lexicon.
+
+/** A span of the source, and the text of a sentence there. */
+export type Placed = { readonly start: number; readonly end: number };
+export type PlacedSentence = Placed & { readonly text: string };
+
+/**
+ * What may follow an opener: a comma, or the end of the sentence. "Before you begin step 3" names one step, and
+ * 「始める前に戻すには」 is a state to return to, not a prerequisite.
+ */
+const AFTER_OPENER = new Set([",", "、", "，", ""]);
+
+/** Whether a sentence opens with one of the openers, as a phrase of its own. */
+export const opensWithPrerequisite = (text: string, openers: readonly string[]): boolean => {
+  const lowered = text.trimStart().toLowerCase();
+  return openers.some((opener) => {
+    const target = opener.toLowerCase();
+    return lowered.startsWith(target) && AFTER_OPENER.has(lowered.charAt(target.length));
+  });
+};
+
+/**
+ * The sentences that open with a prerequisite and come after a numbered procedure ending in the same section. A section's
+ * prerequisite for a later section's steps comes before those steps, in that section, and is not reported.
+ */
+export const latePrerequisites = (
+  sections: readonly Placed[],
+  procedures: readonly Placed[],
+  sentences: readonly PlacedSentence[],
+  openers: readonly string[],
+): PlacedSentence[] =>
+  sentences.filter((sentence) => {
+    if (!opensWithPrerequisite(sentence.text, openers)) return false;
+    const section = sections.findLast((candidate) => candidate.start <= sentence.start && sentence.start < candidate.end);
+    if (section === undefined) return false;
+    return procedures.some((procedure) => procedure.start >= section.start && procedure.end <= sentence.start);
+  });

package/src/profile/parse.ts

@@ -90,7 +90,16 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
         const unnumbered = unnumberedOf(section["unnumbered"]);
         return [
           language,
-          { id, addresses: strings(section["addresses"]), connectives: strings(section["connectives"]), addressEnd, caption, relative, unnumbered },
+          {
+            id,
+            addresses: strings(section["addresses"]),
+            connectives: strings(section["connectives"]),
+            addressEnd,
+            caption,
+            relative,
+            unnumbered,
+            ...(section["quote_mentions_term"] === true ? { quoteMentionsTerm: true } : {}),
+          },
         ];
       }),
   );