chaffjs 0.34.0 → 0.36.0

package/src/person-forms.ts

@@ -104,6 +104,21 @@ const usualForm = (forms: readonly string[]): string | undefined => {
   return [...counts.entries()].reduce<[string, number] | undefined>((best, next) => (best === undefined || next[1] > best[1] ? next : best), undefined)?.[0];
 };
 
+/**
+ * Pure: entries without the places of a form that also names something else (本社 is also the head office), unless that
+ * form is the slot's usual one. A document that calls itself 当社 writes 本社 for its head office; one that calls itself
+ * 本社 still has its stray 当社 pointed at.
+ */
+export const withoutOtherSenses = <T extends { readonly mention: PersonMention }>(entries: readonly T[], otherSenses: ReadonlySet<string>): T[] => {
+  const usual = new Map(
+    [...new Set(entries.map((entry) => entry.mention.slot))].map((slot) => [
+      slot,
+      usualForm(entries.filter((entry) => entry.mention.slot === slot).map((entry) => entry.mention.form)),
+    ]),
+  );
+  return entries.filter((entry) => !otherSenses.has(entry.mention.form) || usual.get(entry.mention.slot) === entry.mention.form);
+};
+
 /**
  * Pure: for each slot, the places that use another form than the document's usual one. Entries are in document order.
  * Nothing when the slot has one form, when the usual form has fewer than MIN_USUAL places, or when the other forms pass

package/src/plugin.ts

@@ -24,6 +24,11 @@ export type Sentence = {
    * 長さの rule はこの単位で数え、この言語の上限と比べる。
    */
   readonly embeddedLanguage?: EmbeddedLanguage;
+  /**
+   * 行頭の印で始まる箇条書きの項目を始める文（「①誓約書」「・〜に関する業務」）。adapter が入れる。
+   * core は項目ごとに段落を改める。
+   */
+  readonly listItem?: true;
 };
 
 export type EmbeddedLanguage = { readonly id: string; readonly lengthUnit: LengthUnit };

package/src/preamble-paragraphs.ts

@@ -19,10 +19,20 @@ const isNameField = (paragraph: Paragraph, source: string): boolean => {
   return value !== undefined && value.split(/\s+/u).every(isNameWord);
 };
 
+/** A note the text attaches to one of its words (※1 特定の走行環境条件), opened by a mark of the note-mark lexicon. */
+const isNote = (paragraph: Paragraph, source: string, noteMarks: readonly string[]): boolean => {
+  const text = source.slice(paragraph.span.start, paragraph.span.end).trimStart();
+  return noteMarks.some((mark) => mark !== "" && text.startsWith(mark));
+};
+
 /**
  * 本題の前にあって、読み手が読み通す段落。文が一つも終止符で閉じない段落は数えない。
  * 分類の札（「エネルギー・環境」）、著者と所属の行、「印刷」、テンプレートの指示は文ではなく、読ませる前置きではない。
- * 宛先や差出人の欄（To: Minato Manufacturing Inc.）も、値が名前だけなら数えない。source は段落の範囲を読む文書。
+ * 宛先や差出人の欄（To: Minato Manufacturing Inc.）も、値が名前だけなら数えない。本文の語に付けた注（※1 …）は、
+ * 前置きの段落ではなく注なので数えない。source は段落の範囲を読む文書、noteMarks は語彙表 note-mark の印。
  */
-export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number, source = ""): Paragraph[] =>
-  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed) && !isNameField(paragraph, source));
+export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number, source = "", noteMarks: readonly string[] = []): Paragraph[] =>
+  paragraphs.filter(
+    (paragraph) =>
+      paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed) && !isNameField(paragraph, source) && !isNote(paragraph, source, noteMarks),
+  );

package/src/sentence-load.ts

@@ -20,18 +20,23 @@ const BRACKETS: Readonly<Record<string, string>> = {
   "“": "”",
 };
 
+/** A closer and the same closer in the other width: a numbering marker written (1） closes the bracket it opened. */
+const OTHER_WIDTH: Readonly<Record<string, string>> = { ")": "）", "）": ")", "]": "］", "］": "]" };
+
 /** A formula written in TeX ($d^k = -\nabla f(x^k)$): its brackets are the formula's, not the sentence's. */
 const FORMULA = /\$\$[^$]*\$\$|\$[^$\n]*\$/gu;
 
 /**
  * The deepest the brackets of a text nest: 「計画（案）」 is one, 「（注（a）を参照）」 two, plain text none. A closer with no
- * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, and formulas in $…$ are skipped.
+ * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, a closer of the other width closes
+ * its opener ((1） is one), and formulas in $…$ are skipped.
  */
 export const bracketDepth = (text: string): number => {
   // The closers still awaited, innermost last. Pushed and popped in place: copying it per character is quadratic on deep nesting.
   const awaited: string[] = [];
   return [...text.replace(FORMULA, " ")].reduce((deepest, char) => {
-    if (awaited.at(-1) === char) awaited.pop();
+    const innermost = awaited.at(-1);
+    if (innermost !== undefined && (innermost === char || innermost === OTHER_WIDTH[char])) awaited.pop();
     else if (BRACKETS[char] !== undefined) awaited.push(BRACKETS[char]);
     return Math.max(deepest, awaited.length);
   }, 0);

package/src/spacing-code.ts

@@ -7,6 +7,8 @@ import { HYPHEN_CHARS } from "./orthography.ts";
 
 /** A clock time: hours, a colon, minutes, and seconds optionally (9:05, 13:30, 08:00:15). */
 const CLOCK_TIME = /(?<![\d:：.])\d{1,2}[:：][0-5]\d(?:[:：][0-5]\d)?(?![\d:：])/gu;
+/** AM or PM written after a clock time, with a space or without (9:30AM, 9:30 p.m.). */
+const MERIDIEM = /^ ?[AaPp]\.?[Mm]\.?(?![A-Za-z])/u;
 
 /** A run of printable ASCII without brackets: an address ends where Japanese text, a space or a bracket starts (…/faq で). */
 const ASCII_RUN = /[!-'*-~]+/gu;
@@ -43,7 +45,9 @@ const SERIAL_DIGITS = /\d{3}/u;
 const spansOf = (text: string, pattern: RegExp): Span[] =>
   [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
 
-export const clockTimeSpans = (text: string): Span[] => spansOf(text, CLOCK_TIME);
+/** Clock times, each with the AM or PM written after it (9:30AM). */
+export const clockTimeSpans = (text: string): Span[] =>
+  spansOf(text, CLOCK_TIME).map((span) => ({ start: span.start, end: span.end + (MERIDIEM.exec(text.slice(span.end))?.[0].length ?? 0) }));
 
 export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).filter((span) => isAddress(text.slice(span.start, span.end)));
 

package/src/split-noun.ts

@@ -0,0 +1,63 @@
+import type { Sentence, Token } from "./plugin.ts";
+import { kanjiSkeleton } from "./kana-spelling.ts";
+
+const ALL_KANJI = /^[\p{Script=Han}々]+$/u;
+/** A bound noun that is kanji and then kana (込み): the okurigana half of a word the tokenizer cut (申 and 込み). */
+const KANJI_THEN_KANA = /^[\p{Script=Han}々]+[ぁ-ゖ]+$/u;
+
+const isTouching = (head: Token, tail: Token): boolean => head.span.end === tail.span.start;
+
+const isKanjiNoun = (token: Token): boolean => token.pos === "NOUN" && ALL_KANJI.test(token.surface);
+
+/** 申 and 込み: a kanji noun and a bound noun of kanji and kana written onto it. */
+const isCutAtKanji = (head: Token, tail: Token): boolean =>
+  isKanjiNoun(head) && tail.pos === "NOUN" && tail.features?.["Bound"] === "Yes" && KANJI_THEN_KANA.test(tail.surface) && isTouching(head, tail);
+
+/**
+ * 申立 and て, the noun's reading already ending in テ (モウシタテ): its last kana cut off as a particle. て never follows a noun as
+ * a particle; other kana (の after 長野, ナガノ) do, so only て is read back.
+ */
+const isCutBeforeTe = (head: Token, tail: Token): boolean =>
+  isKanjiNoun(head) && tail.surface === "て" && (tail.pos === "ADP" || tail.pos === "SCONJ") && head.reading?.endsWith("テ") === true && isTouching(head, tail);
+
+/** The one reading the document gives a noun of these kanji (申込|モウシコミ for 申込); undefined for none or for two. */
+const readingAmong = (kanji: string, nouns: ReadonlySet<string>): string | undefined => {
+  const readings = [...nouns].filter((key) => key.startsWith(`${kanji}|`)).map((key) => key.slice(kanji.length + 1));
+  return readings.length === 1 ? readings[0] : undefined;
+};
+
+const readingOfJoined = (head: Token, tail: Token, nouns: ReadonlySet<string>): string | undefined => {
+  if (isCutAtKanji(head, tail)) return readingAmong(kanjiSkeleton(head.surface + tail.surface), nouns);
+  return isCutBeforeTe(head, tail) ? head.reading : undefined;
+};
+
+const joinedOf = (head: Token, tail: Token | undefined, nouns: ReadonlySet<string>): Token | undefined => {
+  const reading = tail === undefined ? undefined : readingOfJoined(head, tail, nouns);
+  if (tail === undefined || reading === undefined) return undefined;
+  const surface = head.surface + tail.surface;
+  return { span: { start: head.span.start, end: tail.span.end }, surface, pos: "NOUN", lemma: surface, reading };
+};
+
+const joinedTokens = (tokens: readonly Token[], nouns: ReadonlySet<string>): Token[] =>
+  tokens.reduce<{ readonly out: Token[]; readonly skip: boolean }>(
+    ({ out, skip }, token, at) => {
+      if (skip) return { out, skip: false };
+      const joined = joinedOf(token, tokens[at + 1], nouns);
+      out.push(joined ?? token);
+      return { out, skip: joined !== undefined };
+    },
+    { out: [], skip: false },
+  ).out;
+
+/**
+ * The sentence with a noun the tokenizer cut in two read whole: a kanji noun and a bound noun of kanji and kana written onto it
+ * (申 and 込み at the head of a sentence) are one noun (申込み) when the document writes a noun of the same kanji elsewhere
+ * (申し込み, 申込|モウシコミ in nouns), which gives the reading. With no such noun, or two readings for it, the tokens stay as cut.
+ * A kanji noun read with its last kana and that kana cut off as て (申立 and て) is one noun too (申立て).
+ * nouns holds the document's nouns (documentNounKeys).
+ */
+export const withCutNounsJoined = (sentence: Sentence, nouns: ReadonlySet<string>): Sentence => {
+  const tokens = sentence.tokens ?? [];
+  const joined = joinedTokens(tokens, nouns);
+  return joined.length === tokens.length ? sentence : { ...sentence, tokens: joined };
+};

package/src/structure/attached-parts.ts

@@ -0,0 +1,32 @@
+// Where an instrument attached to the document starts: a title line naming it (Exhibit A to Merger Agreement, Annex 1).
+// What is attached is a separate document (a restated charter, a form of note), so its definitions are its own. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import { isTitleLine, type TitleNotion } from "../title-line.ts";
+
+/** An instrument's title: any case (EXHIBIT A to the merger agreement), but no `: ; ,` after it, and only blank lines around. */
+export const INSTRUMENT_TITLE: TitleNotion = { sentenceEnd: /[.!?。．？！:;,]$/u, capitalised: false, edge: "blank-line" };
+
+const linesOf = (source: string): { readonly start: number; readonly text: string }[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ start, text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1) }));
+};
+
+/**
+ * The offsets of the lines that open an attached instrument: the line holds a label (Exhibit, Annex), its letter or
+ * number and at most a short title with no full stop, and a blank line or the document's edge is on both sides.
+ */
+export const attachedPartStarts = (source: string, labels: readonly string[]): number[] => {
+  const words = labels.filter((label) => label !== "").map(escapeRegExp);
+  if (words.length === 0) return [];
+  const title = new RegExp(String.raw`^[ \t]*(?:#{1,6}[ \t]+)?(?:${words.join("|")})[ \t]+[A-Z0-9](?:[A-Z0-9\-]|\.(?=[A-Z0-9]))*(?=[ \t\r]|$)`, "u");
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => {
+    const label = title.exec(line.text);
+    if (label === null) return [];
+    const lineEnd = index === lines.length - 1 ? -1 : line.start + line.text.length;
+    return isTitleLine(source, line.start, lineEnd, line.text.slice(label[0].length), INSTRUMENT_TITLE) ? [line.start] : [];
+  });
+};
+
+/** Which part an offset falls in: 0 for the document itself, n for the n-th attached instrument. */
+export const partAt = (starts: readonly number[], offset: number): number => starts.filter((start) => start <= offset).length;

package/src/structure/build.ts

@@ -9,6 +9,7 @@ import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { universalNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
+import { unspacedHeadings } from "./unspaced-heading.ts";
 import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
 import { foldPostOrder } from "../tree-walk.ts";
 
@@ -260,10 +261,11 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
  * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
  * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
  */
-const headingLineText = (text: string): string => {
+const headingLineText = (text: string, atx: boolean): string => {
   const line = text.trim();
   if (!line.startsWith("#")) return headingText(line);
-  return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
+  // A heading that ends on its own line is ATX, and its hashes go even with no space after them (unspaced-heading.ts).
+  return atxHeadingText(line.replace(atx ? /^#{1,6}/u : /^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
 const captionPatterns = new WeakMap<DocumentProfile, RegExp | undefined>();
@@ -319,7 +321,7 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
 type Around = { readonly next: string | undefined; readonly previous: string | undefined; readonly inTable: boolean };
 
 const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, around: Around): void => {
-  const text = heading === undefined ? line.text : headingLineText(line.text);
+  const text = heading === undefined ? line.text : headingLineText(line.text, heading.end <= line.start + line.text.length);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
   const found = around.inTable ? undefined : (numberedLine(state, patterns, text, context) ?? codeTitledNumber(state, patterns, text, heading, context));
@@ -361,7 +363,8 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
   // コードは同じ長さの空白で覆ってから読む。コードブロックの行は空になって飛ばされ、
   // 文中の `第99条` は参照として拾われない。位置は元の文書のまま。
   const lines = linesOf(maskSpans(input.source, outline.opaque));
-  const headings = headingsByLine(lines, outline.headings);
+  const marked = headingsByLine(lines, outline.headings);
+  const headings = input.markdown ? new Map([...marked, ...unspacedHeadings(lines, marked, patterns)]) : marked;
   const attrs = { path: input.path, language: input.language, ...(input.profile === undefined ? {} : { profile: input.profile.id }) };
   const doc = draftOf("doc", "", { text: "", start: 0, number: 1 }, attrs);
   doc.end = input.source.length;

package/src/structure/cited-document-section.ts

@@ -0,0 +1,42 @@
+import type { StructureNode } from "../plugin.ts";
+
+// 他の文書を引き写した節。「##### 地方公務員法」の下に引いた第十六条の「第六十条」は、地方公務員法の条で、この文書の条ではない。
+
+/** heading: いちばん近い見出しの節の言葉。inArticle: 条の中か。 */
+type Visit = { readonly node: StructureNode; readonly heading: string | undefined; readonly inArticle: boolean };
+
+/** 見出しの言葉。文書の最初の見出しは文書自身の題（「# 就業規則」）なので、他の文書の名前として読まない。 */
+const headingOf = (node: StructureNode, title: StructureNode | undefined): string | undefined =>
+  node === title ? undefined : String(node.attrs["heading"] ?? "").trim();
+
+const documentsCited = (nodes: readonly StructureNode[]): ReadonlySet<string> =>
+  new Set(nodes.flatMap((node) => (node.kind === "reference" && typeof node.attrs["document"] === "string" ? [node.attrs["document"]] : [])));
+
+/** 木を上から順に、見出しの言葉と条の中かと一緒に並べる。再帰にしないのは、深い木でスタックを使い切らないため。 */
+const visitsOf = (tree: StructureNode): Visit[] => {
+  const title = tree.children.find((child) => child.kind === "section");
+  const visits: Visit[] = [];
+  const pending: Visit[] = [{ node: tree, heading: undefined, inArticle: false }];
+  while (pending.length > 0) {
+    const visit = pending.pop();
+    if (visit === undefined) break;
+    visits.push(visit);
+    const { node } = visit;
+    const heading = node.kind === "section" ? headingOf(node, title) : visit.heading;
+    const inArticle = node.kind === "section" ? false : visit.inArticle || node.kind === "article";
+    node.children.toReversed().forEach((child) => pending.push({ node: child, heading, inArticle }));
+  }
+  return visits;
+};
+
+/**
+ * 見出しが他の文書の名前そのものである節に引き写した条の中の参照。その名前を文書がほかで他の文書として引いている
+ * （「地方公務員法第16条」）ときだけ、節はその文書を引き写したものと読む。条の外の地の文の参照は、この文書のもの。Pure.
+ */
+export const referencesInCitedDocuments = (tree: StructureNode): ReadonlySet<StructureNode> => {
+  const visits = visitsOf(tree);
+  const cited = documentsCited(visits.map((visit) => visit.node));
+  if (cited.size === 0) return new Set();
+  const quoted = visits.filter((visit) => visit.node.kind === "reference" && visit.inArticle && visit.heading !== undefined && cited.has(visit.heading));
+  return new Set(quoted.map((visit) => visit.node));
+};

package/src/structure/contents-lines.ts

@@ -0,0 +1,63 @@
+import type { MarkupHeading } from "../plugin.ts";
+import { lineNumberAt, type Line } from "./lines.ts";
+
+// 目次・索引の行と、番号に題だけを続けた行。どれも本文の文ではなく、文書の案内。純関数: 行と Markdown の見出しを受け取る。
+
+/** 項目の終わり（ページ番号、条の番地 2.04(c)）の後ろに、次の項目の大文字が続く所。 */
+const ENTRY_BREAK = /(?<![\p{L}\p{N}$.,])\d+(?:\.\d+)*(?:\([\p{L}\p{N}]{1,4}\))*\s+(?=\p{Lu})/gu;
+/** 一行に詰めた目次・索引と読むのに要る、項目の切れ目の数（Closing 2 Section 1.2 The Merger 2 ARTICLE II）。 */
+const MIN_ENTRY_BREAKS = 3;
+/** 目次・索引の行の言葉は、ほとんどが大文字で始まる。短くない語のうち小文字で始まる語がこの割合以上なら文。 */
+const MAX_LOWERCASE_SHARE = 1 / 3;
+/** これより短い語（of、and、the、番地の (c)、iii）は、題の中でも小文字で書く。 */
+const MIN_CAPITALISED_LENGTH = 4;
+const WORD = /\p{L}[\p{L}'’-]*/gu;
+const LOWERCASE_START = /^\p{Ll}/u;
+
+/** 短くない語のうち、小文字で始まる語の割合。 */
+const lowercaseShare = (text: string): number => {
+  const words = (text.match(WORD) ?? []).filter((word) => word.length >= MIN_CAPITALISED_LENGTH);
+  return words.length === 0 ? 1 : words.filter((word) => LOWERCASE_START.test(word)).length / words.length;
+};
+
+/** 項目と番号を一行に詰めた目次・索引（Section 1.1 Closing 2 Section 1.2 The Merger 2、Company RSU 2.04(b) Company SEC Documents 4.07(a)）。 */
+const isPackedContents = (text: string): boolean => [...text.matchAll(ENTRY_BREAK)].length >= MIN_ENTRY_BREAKS && lowercaseShare(text) < MAX_LOWERCASE_SHARE;
+
+/** 番号に題を続けただけの行（1 Supply of Ingredients）。題の語は大文字で始まり、文の終わりの印を持たない。 */
+const NUMBERED_TITLE = /^\s*\d+(?:\.\d+)*\.?\s+\p{Lu}[^.。:;,!?]*$/u;
+/** 題と読む語の数の上限。 */
+const MAX_TITLE_WORDS = 8;
+
+const NOT_LATIN_LETTER = /[^\P{L}\p{Script=Latin}]/u;
+
+/** 英語の題の言葉か: 語が多すぎず、短くない語がどれも大文字で始まる（Supply of Ingredients、Extension; Waiver）。 */
+export const isTitleWords = (text: string): boolean => {
+  const words = text.match(WORD) ?? [];
+  return (
+    words.length > 0 &&
+    !NOT_LATIN_LETTER.test(text) &&
+    words.length <= MAX_TITLE_WORDS &&
+    words.every((word) => word.length < MIN_CAPITALISED_LENGTH || !LOWERCASE_START.test(word))
+  );
+};
+
+const isNumberedTitle = (text: string): boolean => NUMBERED_TITLE.test(text) && isTitleWords(text);
+
+/** 目次の見出し（語彙表 toc-heading）の下、次の見出しまでの行の番号。 */
+const linesUnderContentsHeading = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): number[] => {
+  const names = new Set(tocWords.map((word) => word.toLowerCase()));
+  return headings.flatMap((heading, index) => {
+    if (!names.has(heading.text.trim().toLowerCase())) return [];
+    const from = lineNumberAt(lines, heading.start) ?? 0;
+    const next = headings[index + 1];
+    const to = next === undefined ? lines.length + 1 : (lineNumberAt(lines, next.start) ?? lines.length + 1);
+    return lines.filter((line) => line.number > from && line.number < to).map((line) => line.number);
+  });
+};
+
+/** 目次・索引の行と、番号に題だけを続けた行の番号（1 始まり）。 */
+export const contentsLineNumbers = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): ReadonlySet<number> =>
+  new Set([
+    ...linesUnderContentsHeading(lines, headings, tocWords),
+    ...lines.filter((line) => isPackedContents(line.text) || isNumberedTitle(line.text)).map((line) => line.number),
+  ]);

package/src/structure/defining-names.ts

@@ -0,0 +1,155 @@
+import { escapeRegExp } from "../orthography.ts";
+
+// 定義の括弧の前に書いた名前と、それを定義より前で写した所。純関数: 文（本文の一続き）と、その中の位置だけを見る。
+
+/** 一つの文。start は文書の中の位置。 */
+type Sentence = { readonly start: number; readonly text: string };
+
+const OPENING_BRACKET = /[\s（(]/u;
+
+/** 定義の括弧を開けた字（（、空白）を後ろから外した、括弧の前の名前。 */
+export const nameBefore = (text: string): string => {
+  let end = text.length;
+  while (end > 0 && OPENING_BRACKET.test(text.charAt(end - 1))) end -= 1;
+  return text.slice(0, end);
+};
+
+/** 二つの文字列が後ろから何字重なるか。 */
+export const sharedTail = (left: string, right: string): number => {
+  let shared = 0;
+  while (shared < left.length && shared < right.length && left.at(-1 - shared) === right.at(-1 - shared)) shared += 1;
+  return shared;
+};
+
+/** 漢字・仮名の名前の頭を決める字。名前はこの字の後ろから括弧の前まで（、株式会社ジェイアール東日本企画（以下「会社」））。 */
+const NAME_BOUNDARY = /[\s、。，．,.;；:：（）()「」『』【】［］[\]]/u;
+const LATIN_NAME_END = /[\p{Script=Latin}\p{N}.]$/u;
+const CAPITALISED = /^[\p{Lu}\p{N}&]/u;
+/** 大文字の語のあいだにだけ入る、短い小文字の語（Board of Directors の of）。 */
+const CONNECTOR = /^\p{Ll}{1,3}$/u;
+const TOKEN = /\S+/gu;
+
+/** 英語の名前: 括弧の前から遡った、大文字で始まる語の並び（Youth Sports Management, LLC、Board of Directors）。 */
+const latinNameIn = (text: string): string => {
+  const tokens = [...text.matchAll(TOKEN)];
+  const kept = (index: number): boolean => {
+    const word = tokens[index]?.[0] ?? "";
+    const previous = tokens[index - 1]?.[0] ?? "";
+    return CAPITALISED.test(word) || (CONNECTOR.test(word) && CAPITALISED.test(previous) && !previous.endsWith(","));
+  };
+  const stop = tokens.findLastIndex((_, index) => !kept(index));
+  const first = tokens[stop + 1];
+  return first === undefined ? "" : text.slice(first.index);
+};
+
+/** 括弧の前の長い名前。英字で終われば大文字の語の並び、そうでなければ句読点・括弧の後ろから。 */
+export const longNameIn = (text: string): string => {
+  if (LATIN_NAME_END.test(text)) return latinNameIn(text);
+  const chars = [...text];
+  return chars.slice(chars.findLastIndex((char) => NAME_BOUNDARY.test(char)) + 1).join("");
+};
+
+/** 定義の括弧の前の名前（name）、その前の文（before）、括弧の中の語より前（head: (this “Agreement”) の (this 。引用符は空白にする）。 */
+export type DefiningName = { readonly name: string; readonly before: string; readonly head: string };
+
+const LETTER_OR_SPACE = /[\p{L}\p{N}\s]/u;
+
+/** 終わりの引用符と強調の印（“、「、***）を空白にしたもの。 */
+const withoutOpeningQuote = (text: string): string => {
+  const chars = [...text];
+  return `${chars.slice(0, chars.findLastIndex((char) => LETTER_OR_SPACE.test(char)) + 1).join("")} `;
+};
+const ROUND_OPEN = new Set(["（", "("]);
+const ROUND_CLOSE = new Set(["）", ")"]);
+
+/** text の終わりで開いたままの丸括弧の位置（…法律（令和6年法律第69号。以下「…」の（）。無ければ undefined。 */
+const openBracketAt = (text: string): number | undefined => {
+  const open: number[] = [];
+  text.split("").forEach((char, index) => {
+    if (ROUND_OPEN.has(char)) open.push(index);
+    else if (ROUND_CLOSE.has(char)) open.pop();
+  });
+  return open.at(-1);
+};
+
+/** 文の中の定義の範囲 [spanStart, spanEnd) から、定義の前の名前を取る。定義が括弧の中の注記の後ろにあれば、その括弧の前の名前。位置は文書の中の位置。 */
+export const definingNameOf = (sentence: Sentence, spanStart: number, spanEnd: number, term: string): DefiningName => {
+  const beforeSpan = sentence.text.slice(0, spanStart - sentence.start);
+  const prefix = nameBefore(beforeSpan.slice(0, openBracketAt(beforeSpan) ?? beforeSpan.length));
+  const name = longNameIn(prefix);
+  const span = sentence.text.slice(spanStart - sentence.start, spanEnd - sentence.start);
+  const termAt = span.indexOf(term);
+  return { name, before: prefix.slice(0, prefix.length - name.length), head: termAt === -1 ? "" : withoutOpeningQuote(span.slice(0, termAt)) };
+};
+
+/** 長い名前の写しと読むのに、語のほかに名前と重ならなければならない字の数（手引き の前の「の」と「成」）。 */
+export const MIN_ECHO = 2;
+const LATIN_WORD_CHAR = /[\p{Script=Latin}\p{N}]/u;
+
+/** 名前の from の位置が英語の語の途中なら、次の語の頭へ進める。limit を越えれば undefined。 */
+const wordStartFrom = (name: string, from: number, limit: number): number | undefined => {
+  if (from === 0 || !LATIN_WORD_CHAR.test(name.charAt(from - 1)) || !LATIN_WORD_CHAR.test(name.charAt(from))) return from;
+  const space = name.slice(from).search(/\s/u);
+  return space === -1 || from + space + 1 > limit ? undefined : from + space + 1;
+};
+
+const indexesOf = (text: string, part: string): number[] => [...text.matchAll(new RegExp(escapeRegExp(part), "gu"))].map((match) => match.index);
+
+/**
+ * 文の at にある語が、定義の名前 name（語を含む、語より長い名前）の写しの中にあるか（Board of Directors (the "Board") より前の
+ * Board of Directors、株式会社エムケイシステム（以下「会社」）より前の株式会社エムケイシステム）。写しは名前の終わりまで同じで、
+ * 頭は名前の語の切れ目から。
+ */
+export const echoesName = (sentence: Sentence, at: number, term: string, name: string): boolean =>
+  name !== term &&
+  indexesOf(name, term).some((index) => {
+    if (!sentence.text.startsWith(name.slice(index + term.length), at + term.length)) return false;
+    const shared = Math.min(index, sharedTail(name.slice(0, index), sentence.text.slice(0, at)));
+    const start = wordStartFrom(name, index - shared, index);
+    return start !== undefined && name.length - start - term.length >= MIN_ECHO;
+  });
+
+const LATIN_LETTER = /\p{Script=Latin}/u;
+
+const SCRIPTS = [/\p{Script=Han}/u, /\p{Script=Hiragana}/u, /\p{Script=Katakana}/u];
+
+/** 二つの字が同じ字の種類（漢字、平仮名、片仮名）か。基本規程の「本」は、前の「基」と一続きの語の一部。 */
+const sameScript = (left: string, right: string): boolean => SCRIPTS.some((script) => script.test(left) && script.test(right));
+
+/** 漢字・仮名の頭が、前の語に続かずに text の終わりにあるか（この規則、本規程。基本規程の本、そこの規則のこの は当たらない）。 */
+const endsWithWordPrefix = (text: string, prefix: string): boolean =>
+  text.endsWith(prefix) && !sameScript(text.charAt(text.length - prefix.length - 1), prefix.charAt(0));
+
+/** text の終わりが、文書自身を指す頭（この、本、this）か。英語の頭は語として（this の後ろに空白）、大文字小文字を問わない。 */
+const endsWithSelfPrefix = (text: string, prefixes: readonly string[]): boolean =>
+  prefixes.some((prefix) =>
+    LATIN_LETTER.test(prefix) ? new RegExp(String.raw`(?<![\p{L}\p{N}])${escapeRegExp(prefix)}\s+$`, "iu").test(text) : endsWithWordPrefix(text, prefix),
+  );
+
+/** 定義が文書自身の名前か（この就業規則（以下「規則」）、本規程（以下「規程」）、This Agreement … (this "Agreement")）。 */
+export const namesItself = (defining: DefiningName, prefixes: readonly string[]): boolean =>
+  endsWithSelfPrefix(defining.head, prefixes) ||
+  endsWithSelfPrefix(defining.before, prefixes) ||
+  prefixes.some((prefix) => !LATIN_LETTER.test(prefix) && defining.name.startsWith(prefix));
+
+/** 文の at の語の前が、文書自身を指す頭か（この規則、this Agreement）。 */
+export const followsSelfPrefix = (sentence: Sentence, at: number, prefixes: readonly string[]): boolean =>
+  endsWithSelfPrefix(sentence.text.slice(0, at), prefixes);
+
+/** 前の語を見るのに遡る字の数。 */
+const LOOK_BEHIND_CHARS = 80;
+/** 語の前が、文の頭ではない大文字の語か（Navistar Financial Corporation の Corporation）。The Company の The は文の頭なので当たらない。 */
+const AFTER_CAPITALISED_WORD = /\p{L}[ \u00a0]\p{Lu}[\p{L}\p{N}&'’-]*[ \u00a0]$/u;
+
+/** 英語の語が、前の大文字の語から続く長い名前の終わりにあるか。 */
+export const endsLatinName = (sentence: Sentence, at: number, term: string): boolean =>
+  LATIN_LETTER.test(term.charAt(0)) && AFTER_CAPITALISED_WORD.test(sentence.text.slice(Math.max(0, at - LOOK_BEHIND_CHARS), at));
+
+/** 語のすぐ後ろの括弧とその中身（こども性暴力防止法（…に関する法律）の（…に関する法律））。 */
+const GLOSS_AFTER = /^\s*[（(]([^）)]*)[）)]/u;
+
+/** 文の at の語が、すぐ後ろの括弧に定義の長い名前を書き添えているか。語の意味はその場で分かる。 */
+export const glossedWithName = (sentence: Sentence, at: number, term: string, name: string): boolean => {
+  const gloss = GLOSS_AFTER.exec(sentence.text.slice(at + term.length))?.[1];
+  return gloss !== undefined && name.length >= term.length + MIN_ECHO && gloss.trim().endsWith(name);
+};