chaffjs 0.27.1 → 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,13 +1,28 @@
 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）、読みが同じ（山田太郎 と 山田太朗）、
 // 英字の一字違い（Microsoft と Microsft）。一字違いは別の名前でもありうるので、多いほうが二度以上、少ないほうが一度だけのときに限る。
 
-/** words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。 */
-export type NameMention = { readonly surface: string; readonly offset: number; readonly reading: string | undefined; readonly words: readonly string[] };
+/**
+ * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
+ * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。
+ */
+export type NameMention = {
+  readonly surface: string;
+  readonly offset: number;
+  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" };
+export type NameVariant = { readonly mention: NameMention; readonly usual: string; readonly kind: "spelling" | "reading" | "near" | "character" };
+
+/** 字体の違う同じ字（斎・斉・齋）。字から、その組の代表の字へ。 */
+export type VariantChars = ReadonlyMap<string, string>;
 
 const NAME = "PROPN";
 /**
@@ -58,11 +73,18 @@ const withoutEdgeQuotes = (text: string): string => {
  */
 const NOT_COMPARED = /@|(?:^|\s)\p{L}(?:\s|$)/u;
 
+/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
+const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
+
+/** 人の名前か。解析器が人名と読む語を含むか、すぐ後ろに敬称（様、さん、氏）が付く。 */
+const isPerson = (run: readonly Token[], next: Token | undefined, suffixes: readonly string[]): boolean =>
+  run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (next !== undefined && suffixes.includes(next.surface));
+
 /**
  * 文の語から、名前の現れ。surface は source の上の書いたまま（折り返しの空白は一つにまとめる）。
  * 大文字だけの名前（ACME INC、NASA）は外す。契約書の署名欄や略語で、ふつうの書き方の別の形ではない。小文字の英字だけの語も外す。
  */
-export const mentionsIn = (tokens: readonly Token[], source: string): NameMention[] =>
+export const mentionsIn = (tokens: readonly Token[], source: string, personSuffixes: readonly string[] = []): NameMention[] =>
   runsOf(tokens).flatMap((run) => {
     const first = run[0];
     const last = run.at(-1);
@@ -73,7 +95,53 @@ export const mentionsIn = (tokens: readonly Token[], source: string): NameMentio
     const words = run.filter((token) => !JOINERS.has(token.surface));
     const readings = words.map((token) => token.reading);
     const reading = readings.every((value) => value !== undefined && value !== "") ? readings.join("") : undefined;
-    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface) }];
+    const person = isPerson(run, tokens[tokens.indexOf(last) + 1], personSuffixes);
+    return [{ surface, offset: first.span.start, reading, words: words.map((token) => token.surface), person }];
+  });
+
+/** 敬称の前の名前の字数（髙橋、髙橋太郎）。長い漢字の連なり（株式会社髙橋）は名前だけを切り出せない。 */
+const MAX_SUFFIXED_NAME = 4;
+const MIN_SUFFIXED_NAME = 2;
+/** 敬称の前を読む範囲（UTF-16 の単位）。名前より長い漢字の連なりを、長いまま見るため。 */
+const SUFFIX_LOOKBACK = 20;
+const HAN = /^\p{Script=Han}$/u;
+
+/** 文字列の終わりの漢字の連なり。 */
+const trailingHan = (text: string): string => {
+  const letters = [...text];
+  return letters.slice(letters.findLastIndex((letter) => !HAN.test(letter)) + 1).join("");
+};
+
+/**
+ * 解析器が名前と読めなかった、字体の違う字を含む人の名前（髙橋様、𠮷田様、﨑山様）。敬称のすぐ前の漢字の連なりで、語彙表の字を
+ * 含み、ほかの名前の現れと重ならないもの。
+ */
+export const suffixedNamesIn = (source: string, suffixes: readonly string[], chars: VariantChars, taken: readonly NameMention[]): NameMention[] =>
+  suffixes.flatMap((suffix) =>
+    [...source.matchAll(new RegExp(escapeRegExp(suffix), "gu"))].flatMap((match) => {
+      const run = trailingHan(source.slice(Math.max(0, match.index - SUFFIX_LOOKBACK), match.index));
+      const length = [...run].length;
+      if (length < MIN_SUFFIXED_NAME || length > MAX_SUFFIXED_NAME || ![...run].some((letter) => chars.has(letter))) return [];
+      const offset = match.index - run.length;
+      if (taken.some((mention) => mention.offset < match.index && offset < mention.offset + mention.surface.length)) return [];
+      return [{ surface: run, offset, reading: undefined, words: [run], person: true }];
+    }),
+  );
+
+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）、大文字小文字、空白と記号は名前を変えない。 */
@@ -83,14 +151,38 @@ export const nameKey = (surface: string): string =>
     .toLowerCase()
     .replaceAll(/[\s\p{P}\p{S}]/gu, "");
 
-type Tally = { readonly surface: string; readonly first: NameMention; readonly count: number };
+/**
+ * 名前の現れから言えること。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 }>();
+  const tallies = new Map<string, Tally>();
   mentions.forEach((mention) => {
     const tally = tallies.get(mention.surface);
-    if (tally === undefined) tallies.set(mention.surface, { surface: mention.surface, first: mention, count: 1 });
-    else tally.count += 1;
+    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()];
 };
@@ -191,8 +283,55 @@ const isSlipOf = (tally: Tally, other: Tally): boolean => {
 
 const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf);
 
-/** 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。 */
-export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] => {
+/** 字体の違う字（斎と斉）を組の代表の字に寄せた形。 */
+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 || tally.nameLike),
+      (tally) => [characterKey(tally, chars)],
+    ),
+    "character",
+    isCharacterPair,
+  );
+
+/** 字数が同じで、一字だけが違う（松本 と 松元）。 */
+const oneCharApart = (left: string, right: string): boolean => {
+  const [leftChars, rightChars] = [[...left], [...right]];
+  return leftChars.length === rightChars.length && leftChars.filter((char, index) => char !== rightChars[index]).length === 1;
+};
+
+/**
+ * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、多いほうが二度以上、
+ * 少ないほうが一度だけのときに限る。
+ */
+const isPersonSlipOf = (tally: Tally, other: Tally): boolean => tally.count === 1 && other.count >= 2 && oneCharApart(tally.surface, other.surface);
+
+const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
+  variantsIn(
+    groupBy(
+      tallies.filter((tally) => tally.person),
+      (tally) => (tally.first.reading === undefined ? [] : [tally.first.reading]),
+    ),
+    "reading",
+    isPersonSlipOf,
+  );
+
+/**
+ * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
+ * 違う同じ字の組（語彙表 name-variant-char）。
+ */
+export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map()): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
@@ -205,6 +344,8 @@ export const nameVariants = (mentions: readonly NameMention[]): NameVariant[] =>
       oneWordApart,
     ),
     ...nearVariants(tallies),
+    ...characterVariants(tallies, chars),
+    ...personReadingVariants(tallies),
   ];
   const reported = new Set<string>();
   return found

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