chaffjs 0.28.0 → 0.29.0

package/src/nado-closed-list.ts

@@ -0,0 +1,106 @@
+// A list left open (等, など, etc.) that a limit closes in the same breath (自転車等に限ります, only A, B, etc.). Pure: reads one
+// sentence's text and tokens; the open words, the limits and the phrases that look like a limit without being one come
+// from the language's nado-closed-list lexicon.
+import type { LexiconEntry, Token } from "./plugin.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+export type ClosedListWords = {
+  readonly open: readonly string[];
+  /** A limit right after the open word (等に限り, etc. only). */
+  readonly limitsAfter: readonly string[];
+  /** A limit before the list it governs (only A, B, etc.). */
+  readonly limitsBefore: readonly string[];
+  /** A phrase holding a limit's letters that closes nothing (に限らず, not only). */
+  readonly notLimits: readonly string[];
+};
+
+/** An open word on a closed list: where it is in the sentence, the word and the limit. */
+export type OpenOnClosed = { readonly offset: number; readonly open: string; readonly limit: string };
+
+const patternsOf = (entries: readonly LexiconEntry[], group: string, position?: "before" | "after"): string[] =>
+  entries.filter((entry) => entry.group === group && (position === undefined || entry.position === position)).map((entry) => entry.pattern);
+
+export const closedListWordsOf = (entries: readonly LexiconEntry[]): ClosedListWords => ({
+  open: patternsOf(entries, "open"),
+  limitsAfter: patternsOf(entries, "limit", "after"),
+  limitsBefore: patternsOf(entries, "limit", "before"),
+  notLimits: patternsOf(entries, "not-limit"),
+});
+
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER = /\p{L}/u;
+/** What may stand between an open word and a limit right after it: spaces, a comma, a closing bracket. */
+const BETWEEN_OPEN_AND_LIMIT = /^[\s,、)）」』]*/u;
+/** A word that is a counter or a class (1等, 2等), not an open word, by the tagger's features. */
+const CLASS_NOUN = "Class";
+/** What makes the words between a limit and an open word a clause of their own, not the list it governs. */
+const CLAUSE_POS: ReadonlySet<string> = new Set(["AUX", "VERB"]);
+/** A verb form that modifies a noun inside a list (a driving licence, used cars). */
+const NOUN_MODIFYING_FORMS: ReadonlySet<string> = new Set(["Ger", "Part"]);
+const LIST_SEPARATOR = /[,、]/u;
+
+/** Where a word occurs in a text; a Latin word only as whole words, any case. */
+const placesOf = (text: string, word: string): number[] => {
+  const latin = LATIN_START.test(word);
+  const matches = [...text.matchAll(new RegExp(escapeRegExp(word), latin ? "giu" : "gu"))].map((match) => match.index);
+  if (!latin) return matches;
+  return matches.filter((at) => !LETTER.test(text[at - 1] ?? "") && !LETTER.test(text[at + word.length] ?? ""));
+};
+
+const startsWithWord = (text: string, word: string): boolean => placesOf(text.slice(0, word.length + 1), word).includes(0);
+
+/**
+ * The open word stands as a word of its own: a token starts there, is no longer than the word (等しい, 同等 are other
+ * words), and is not a counter (1等). Token spans are the sentence's own offsets. Without tokens only a Latin word is read.
+ */
+const standsAsOpenWord = (tokens: readonly Token[], at: number, open: string): boolean => {
+  if (tokens.length === 0) return LATIN_START.test(open);
+  const token = tokens.find((candidate) => candidate.span.start === at);
+  return token !== undefined && open.toLowerCase().startsWith(token.surface.toLowerCase()) && token.features?.NounType !== CLASS_NOUN;
+};
+
+const limitRightAfter = (rest: string, words: ClosedListWords): string | undefined => {
+  const after = rest.slice(BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0].length ?? 0);
+  if (words.notLimits.some((phrase) => startsWithWord(after, phrase))) return undefined;
+  return longestFirst(words.limitsAfter).find((limit) => startsWithWord(after, limit));
+};
+
+const longestFirst = (words: readonly string[]): string[] => [...words].sort((a, b) => b.length - a.length);
+
+const insideNotLimit = (text: string, at: number, notLimits: readonly string[]): boolean =>
+  notLimits.some((phrase) => placesOf(text, phrase).some((start) => start <= at && at < start + phrase.length));
+
+const OPEN_BRACKETS = /[(（]/gu;
+const CLOSE_BRACKETS = /[)）]/gu;
+
+/** A bracket opened and not closed between the limit and the list: the list explains a word the limit governs. */
+const opensBracket = (between: string): boolean => (between.match(OPEN_BRACKETS)?.length ?? 0) > (between.match(CLOSE_BRACKETS)?.length ?? 0);
+
+/** The words between a limit and the open word are a list it governs: separated by commas, with no clause of their own. */
+const governsList = (text: string, tokens: readonly Token[], from: number, to: number): boolean =>
+  LIST_SEPARATOR.test(text.slice(from, to)) &&
+  !opensBracket(text.slice(from, to)) &&
+  !tokens.some(
+    (token) => token.span.start >= from && token.span.end <= to && CLAUSE_POS.has(token.pos) && !NOUN_MODIFYING_FORMS.has(token.features?.VerbForm ?? ""),
+  );
+
+const limitBefore = (text: string, tokens: readonly Token[], at: number, words: ClosedListWords): string | undefined => {
+  const limits = words.limitsBefore.flatMap((limit) =>
+    placesOf(text.slice(0, at), limit).map((start) => ({ limit, start, end: start + limit.length, negated: insideNotLimit(text, start, words.notLimits) })),
+  );
+  const nearest = limits.toSorted((a, b) => b.start - a.start)[0];
+  if (nearest === undefined || nearest.negated) return undefined;
+  return governsList(text, tokens, nearest.end, at) ? nearest.limit : undefined;
+};
+
+/** The open words of one sentence that a limit closes, by their offset in the sentence. */
+export const openWordsOnClosedLists = (text: string, tokens: readonly Token[], words: ClosedListWords): OpenOnClosed[] =>
+  words.open
+    .flatMap((open) => placesOf(text, open).map((at) => ({ open, at })))
+    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open))
+    .flatMap(({ open, at }) => {
+      const limit = limitRightAfter(text.slice(at + open.length), words) ?? limitBefore(text, tokens, at, words);
+      return limit === undefined ? [] : [{ offset: at, open, limit }];
+    })
+    .sort((a, b) => a.offset - b.offset || b.open.length - a.open.length)
+    .filter((hit, index, hits) => hits[index - 1]?.offset !== hit.offset);

package/src/name-cue.ts

@@ -0,0 +1,35 @@
+// 敬称も、解析器の人名の印も無い名前（担当の斎藤です、斉藤までご連絡ください）を、前後の語から人の名前と読む。
+
+/** 人を指す前置き（担当の、私、）、敬称（様、さん）、名前のすぐ後ろに来る語（です、まで）。語彙表から。 */
+export type NameCues = { readonly leads: readonly string[]; readonly suffixes: readonly string[]; readonly particles: readonly string[] };
+
+/**
+ * person: 人の名前と言える（前に「担当の」、後ろに敬称）。slot: 名前の来る場所（後ろに「です」「まで」）。bare: どちらでもない。
+ * 名前の形でないもの（字数が違う、漢字以外を含む、長い漢字の連なりの一部）は undefined。
+ */
+export type NameCue = "person" | "slot" | "bare";
+
+const MIN_NAME = 2;
+const MAX_NAME = 4;
+/** 前後の一字を読むのに要る長さ（UTF-16 の単位）。𠮷 は二つ。 */
+const SURROGATE_PAIR = 2;
+const HAN = /^\p{Script=Han}$/u;
+
+const isHan = (letter: string | undefined): boolean => letter !== undefined && HAN.test(letter);
+
+/**
+ * offset から書いた surface を、前後の語で読む。名前は 2〜4 字の漢字で、前後に漢字が続かない（鹿嶋市、株式会社髙橋は地名や会社の名前の
+ * 一部）。敬称だけは漢字（様、氏）でも名前のすぐ後ろに続いてよい。
+ */
+export const nameCueAt = (text: string, offset: number, surface: string, cues: NameCues): NameCue | undefined => {
+  const letters = [...surface];
+  if (letters.length < MIN_NAME || letters.length > MAX_NAME || !letters.every((letter) => isHan(letter))) return undefined;
+  const context = Math.max(SURROGATE_PAIR, ...[...cues.leads, ...cues.suffixes, ...cues.particles].map((word) => word.length));
+  const before = text.slice(Math.max(0, offset - context), offset);
+  const after = text.slice(offset + surface.length, offset + surface.length + context);
+  if (isHan([...before].at(-1))) return undefined;
+  if (cues.suffixes.some((suffix) => after.startsWith(suffix))) return "person";
+  if (isHan([...after][0])) return undefined;
+  if (cues.leads.some((lead) => before.endsWith(lead))) return "person";
+  return cues.particles.some((particle) => after.startsWith(particle)) ? "slot" : "bare";
+};

package/src/name-variants.ts

@@ -1,5 +1,6 @@
 import type { Token } from "./plugin.ts";
 import { escapeRegExp } from "./orthography.ts";
+import { nameCueAt, type NameCue, type NameCues } from "./name-cue.ts";
 
 // 同じ名前（人・会社・製品）を、文書の中で少しだけ違う形に書いた所。どの形が正しいかは決めず、少ないほうを指す。
 // 三通りで同じ名前と見る。書き方の違いだけ（GitHub と Github、Mac OS と macOS）、読みが同じ（山田太郎 と 山田太朗）、
@@ -7,7 +8,7 @@ import { escapeRegExp } from "./orthography.ts";
 
 /**
  * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
- * 人名と読むか、敬称が付く）。
+ * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。
  */
 export type NameMention = {
   readonly surface: string;
@@ -15,6 +16,7 @@ export type NameMention = {
   readonly reading: string | undefined;
   readonly words: readonly string[];
   readonly person?: boolean;
+  readonly cue?: NameCue;
 };
 
 export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" | "character" };
@@ -126,6 +128,22 @@ export const suffixedNamesIn = (source: string, suffixes: readonly string[], cha
     }),
   );
 
+const HAN_RUN = /\p{Script=Han}+/gu;
+
+/**
+ * 解析器が名前と読めず、敬称も無いが、前後の語で名前と読める、字体の違う字を含む漢字（担当の髙橋です、髙橋まで）。
+ * ほかの名前の現れと重ならないもの。
+ */
+export const cuedNamesIn = (source: string, cues: NameCues, chars: VariantChars, taken: readonly NameMention[]): NameMention[] =>
+  [...source.matchAll(HAN_RUN)].flatMap((match) => {
+    const [run] = match;
+    const cue = nameCueAt(source, match.index, run, cues);
+    if (cue === undefined || cue === "bare" || ![...run].some((letter) => chars.has(letter))) return [];
+    const end = match.index + run.length;
+    if (taken.some((mention) => mention.offset < end && match.index < mention.offset + mention.surface.length)) return [];
+    return [{ surface: run, offset: match.index, reading: undefined, words: [run], cue }];
+  });
+
 /** 比べる形。幅（ＡＷＳ と AWS）、大文字小文字、空白と記号は名前を変えない。 */
 export const nameKey = (surface: string): string =>
   surface
@@ -133,19 +151,38 @@ export const nameKey = (surface: string): string =>
     .toLowerCase()
     .replaceAll(/[\s\p{P}\p{S}]/gu, "");
 
-/** person: どれかの現れが人の名前と読める。 */
-type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number; readonly person: boolean };
+/**
+ * 名前の現れから言えること。person: 人の名前と読める。named: 人を指す前置きか敬称が付く。nameLike: 名前の来る場所にある（前置き
+ * か敬称、名前のすぐ後ろに来る語）。解析器の人名の印は地名にも付く（鹿嶋へ）ので、nameLike には数えない。
+ */
+export type NameEvidence = { readonly person: boolean; readonly named: boolean; readonly nameLike: boolean };
 
+type Tally = NameEvidence & { readonly surface: string; readonly first: NameMention; readonly count: number };
+
+const evidenceOf = (mention: NameMention): NameEvidence => ({
+  person: mention.person === true,
+  named: mention.cue === "person",
+  nameLike: mention.cue === "person" || mention.cue === "slot",
+});
+
+/** 書き方ごとの数と、どれかの現れが言えること。 */
 const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
-  const tallies = new Map<string, { surface: string; first: NameMention; count: number; person: boolean }>();
+  const tallies = new Map<string, Tally>();
   mentions.forEach((mention) => {
     const tally = tallies.get(mention.surface);
-    const person = mention.person === true;
-    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1, person });
-    else {
-      tally.count += 1;
-      tally.person ||= person;
-    }
+    const evidence = evidenceOf(mention);
+    tallies.set(
+      mention.surface,
+      tally === undefined
+        ? { surface: mention.surface, first: mention, count: 1, ...evidence }
+        : {
+            ...tally,
+            count: tally.count + 1,
+            person: tally.person || evidence.person,
+            named: tally.named || evidence.named,
+            nameLike: tally.nameLike || evidence.nameLike,
+          },
+    );
   });
   return [...tallies.values()];
 };
@@ -249,14 +286,23 @@ const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(gr
 /** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
 const characterKey = (tally: Tally, chars: VariantChars): string => [...tally.surface].map((letter) => chars.get(letter) ?? letter).join("");
 
+/**
+ * 字体の違う字で書き分けた二つを、同じ人の名前と見るか。どちらも人の名前と読めるか、片方に人を指す前置きか敬称が付き
+ * （担当の斎藤です）、もう片方が名前の来る場所にある（斉藤まで）。地名にも同じ組がある（鹿島 と 鹿嶋）ので、名前の来る場所どうし
+ * だけでは見ない。
+ */
+export const isCharacterPair = (left: NameEvidence, right: NameEvidence): boolean =>
+  (left.person && right.person) || (left.named && right.nameLike) || (right.named && left.nameLike);
+
 /** 人の名前を、字体の違う同じ字（斎藤 と 斉藤、渡辺 と 渡邊）で書き分けた所。 */
 const characterVariants = (tallies: readonly Tally[], chars: VariantChars): NameVariant[] =>
   variantsIn(
     groupBy(
-      tallies.filter((tally) => tally.person),
+      tallies.filter((tally) => tally.person || tally.nameLike),
       (tally) => [characterKey(tally, chars)],
     ),
     "character",
+    isCharacterPair,
   );
 
 /** 字数が同じで、一字だけが違う（松本 と 松元）。 */

package/src/paragraph-runs.ts

@@ -14,13 +14,23 @@ const isAdjacent = (source: string, before: Paragraph, after: Paragraph): boolea
   return between.trim() === "" && BLANK_LINE.test(between);
 };
 
+/** A sentence's last mark, past closing quotes, brackets and emphasis marks. */
+const SENTENCE_END = /[。．.!?！？]["'”’」』)）\]］}｝】》〕〉〛*_]*$/u;
+
+/**
+ * Whether a paragraph ends as a sentence does. One that does not is a label, a field, a line of a flattened table or a heading
+ * written as plain text (日時：, Authors, 490 Ratings), which sets nothing apart.
+ */
+export const endsAsSentence = (source: string, paragraph: Paragraph): boolean =>
+  SENTENCE_END.test(source.slice(paragraph.span.start, paragraph.span.end).trim());
+
 /**
  * Each run of adjacent one-sentence paragraphs, in document order, as the paragraphs it holds. A paragraph of two sentences or
- * more, or anything between two paragraphs, ends the run.
+ * more, a paragraph that does not end as a sentence, or anything between two paragraphs, ends the run.
  */
 export const oneSentenceRuns = (source: string, paragraphs: readonly Paragraph[]): Paragraph[][] =>
   paragraphs.reduce<Paragraph[][]>((runs, paragraph, at) => {
-    if (paragraph.sentences.length !== 1) return runs;
+    if (paragraph.sentences.length !== 1 || !endsAsSentence(source, paragraph)) return runs;
     const previous = paragraphs[at - 1];
     const current = runs.at(-1);
     const continues = previous !== undefined && current?.at(-1) === previous && isAdjacent(source, previous, paragraph);

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);
+};