chaffjs 0.14.0 → 0.16.0

package/src/detectors/acronym-expansion.ts

@@ -9,7 +9,9 @@ import { escapeRegExp } from "../orthography.ts";
  *   Continuous Integration (CI)      括弧の中が略語
  *   Tax Cuts and Jobs Act [TCJA]     角括弧の中が略語で、直前の語の頭文字と揃う
  *   Relief Act (RA; P.L. 112-240)    括弧の最初の項目が略語で、直前の語か区切りの後の語の頭文字と揃う
+ *   （single nucleotide polymorphism：SNP）  括弧の最後の項目が略語で、コロンの前の語の頭文字と揃う
  *   人事部（以下「HR」という。）      括弧の中が定義の語と略語だけ
+ *   overnight reverse repurchase agreement (ON RRP)  括弧の中が空白で繋いだ略語だけで、前の名前から文字が順に拾える
  * 括弧と略語の間には、引用符（(“MNDA”)、（「MNDA」））と空白だけを許す。
  */
 const WRAP = String.raw`[\s"“”'‘’「」『』]*`;
@@ -20,7 +22,9 @@ const SQUARE_CLOSES = new RegExp(String.raw`^${WRAP}\]`, "u");
 const SQUARE_OPENED = new RegExp(String.raw`\[${WRAP}$`, "u");
 const ANY_OPENED = new RegExp(String.raw`[(（[]${WRAP}$`, "u");
 /** 括弧の最初の項目のあとの区切りと、括弧が閉じるまでの残り（(ARRA; P.L. 111-5)、（OP、Originator Profile））。 */
-const SEPARATED = new RegExp(String.raw`^${WRAP}[;；,，、](?<rest>[^()（）]*)`, "u");
+const SEPARATED = new RegExp(String.raw`^${WRAP}[;；,，、:：](?<rest>[^()（）]*)`, "u");
+/** 括弧の中の名前とコロンのあと、略語の直前まで（（single nucleotide polymorphism：SNP））。名前に区切りがあれば列挙なので外す。 */
+const NAMED_BEFORE = new RegExp(String.raw`[(（](?<name>[^()（）;；,，、:：]*)[:：]${WRAP}$`, "u");
 const QUOTES = /["“”'‘’「」『』]/gu;
 
 /** 括弧と略語の間の幅。空白は 1 つに畳んであるので、(“ MNDA ”) まで収まる。 */
@@ -36,7 +40,7 @@ const MARKER_GAP = String.raw`(?![A-Za-z])[\s、,]*`;
  * 角括弧は引用の印にも使う（[IANA]、[1]）。直前の語のうち大文字で始まる語の頭文字が
  * 略語と揃うときだけ展開と見なす。見る語は略語の文字数の 2 倍まで（and や of を挟むため）。
  */
-const lettersOf = (acronym: string): string => acronym.replaceAll("&", "");
+const lettersOf = (acronym: string): string => acronym.replaceAll(/[&-]/gu, "");
 
 const initialsOf = (words: readonly string[]): string =>
   words
@@ -54,6 +58,17 @@ const spellsOut = (before: string, acronym: string): boolean => {
   return initialsOf(words).endsWith(letters);
 };
 
+/**
+ * 括弧の中で略語と組になる名前の頭文字が、略語とちょうど揃うか。大文字で始まる語だけの頭文字（Data Retention and Reuse Act）か、
+ * すべての語の頭文字（single nucleotide polymorphism）で比べる。後者は大文字小文字を問わない。
+ */
+export const namesAcronym = (name: string, acronym: string): boolean => {
+  const words = name.replace(QUOTES, " ").trim().split(/\s+/u);
+  const letters = lettersOf(acronym);
+  const allInitials = words.map((word) => word.charAt(0)).join("");
+  return initialsOf(words) === letters || allInitials.toUpperCase() === letters.toUpperCase();
+};
+
 /**
  * 括弧の最初の項目が略語で、区切りのあとに注記が続く形（(ARRA; P.L. 111-5)、（OP、Originator Profile））。
  * 同じ形で列挙も書く（(MR, handbook, etc.)、(EPA, FDIC, GSA)）ので、直前の語か、区切りから括弧が閉じるまでの語の
@@ -66,7 +81,14 @@ const isSeparatedAt = (body: string, acronym: string, at: number): boolean => {
   const rest = separated.groups?.["rest"] ?? "";
   const end = at + acronym.length + separated[0].length;
   const closed = CLOSES.test(body.slice(end, end + NEAR));
-  return spellsOut(body.slice(0, at), acronym) || (closed && initialsOf(rest.replace(QUOTES, " ").trim().split(/\s+/u)) === lettersOf(acronym));
+  return spellsOut(body.slice(0, at), acronym) || (closed && namesAcronym(rest, acronym));
+};
+
+/** 括弧の最後の項目が略語で、コロンの前に名前を書く形（（Information-technology Promotion Agency：IPA））。 */
+const isNamedBeforeAt = (body: string, acronym: string, at: number): boolean => {
+  const named = NAMED_BEFORE.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at));
+  if (named === null || !CLOSES.test(body.slice(at + acronym.length, at + acronym.length + NEAR))) return false;
+  return namesAcronym(named.groups?.["name"] ?? "", acronym);
 };
 
 /** 言語パッケージの語彙表から読む、括弧の中で略語の前に書く語（以下、hereinafter）と後ろに書く語（という）。 */
@@ -92,18 +114,63 @@ const isDefinedAt = (patterns: DefinitionPatterns, body: string, acronym: string
   return (opened.groups?.["markers"] ?? "") !== "" || (closes.groups?.["verb"] ?? "") !== "";
 };
 
+/** 空白 1 つで繋いだ略語の並びのうち、at の略語の前と後ろに続く分（(ON RRP) の ON の後ろの " RRP"）。 */
+const CAPITALS = "[A-Z][A-Z&-]*[A-Z]";
+const JOINT_BEFORE = new RegExp(String.raw`(?:(?<![A-Za-z0-9_&-])${CAPITALS} )+$`, "u");
+const JOINT_AFTER = new RegExp(String.raw`^(?: ${CAPITALS}(?![A-Za-z0-9_&-]))+`, "u");
+
+const LOWER_WORDS = /[a-z]+/gu;
+
+const isSubsequence = (letters: string, text: string): boolean =>
+  [...text].reduce((matched, char) => (char === letters.charAt(matched) ? matched + 1 : matched), 0) === letters.length;
+
+/**
+ * 略語の文字が、名前のどれかの語の頭から始まって、名前の文字の中に順に拾えるか。1 つの略語を空白で分けて書くときは、
+ * 語の頭文字ではなく語の途中の文字も使う（overnight reverse repurchase agreement → ON RRP）。見る語は略語の文字数の 2 倍まで。
+ */
+export const abbreviates = (name: string, acronym: string): boolean => {
+  const letters = acronym.toLowerCase().replaceAll(/[^a-z]/gu, "");
+  const words = (name.toLowerCase().match(LOWER_WORDS) ?? []).slice(-letters.length * 2);
+  return letters !== "" && words.some((word, index) => word.startsWith(letters.charAt(0)) && isSubsequence(letters, words.slice(index).join("")));
+};
+
+/**
+ * 括弧の中身が、空白で繋いだ略語の並びだけの形（(ON RRP)）。1 つの略語を 2 語以上で書いたもの。並びの文字が括弧の前の名前から
+ * 順に拾えるときだけ展開と見なす。拾えなければ、空白で並べた略語の列挙（(SEC FINRA)）。
+ * 括弧の外の並び（AWS KMS (Key Management Service)）は、括弧の直前の語だけが展開されるので、ここでは見ない。
+ */
+const isJointBracketedAt = (body: string, acronym: string, at: number): boolean => {
+  const end = at + acronym.length;
+  const before = JOINT_BEFORE.exec(body.slice(Math.max(0, at - DEFINITION_REACH), at))?.[0] ?? "";
+  const after = JOINT_AFTER.exec(body.slice(end, end + DEFINITION_REACH))?.[0] ?? "";
+  const start = at - before.length;
+  const close = end + after.length;
+  if (!OPENED.test(body.slice(Math.max(0, start - NEAR), start)) || !CLOSES.test(body.slice(close, close + NEAR))) return false;
+  return abbreviates(body.slice(0, start), body.slice(start, close));
+};
+
 const isBracketedAt = (body: string, acronym: string, at: number): boolean => {
   const after = body.slice(at + acronym.length, at + acronym.length + NEAR);
   const before = body.slice(Math.max(0, at - NEAR), at);
   if (OPENS.test(after) || (OPENED.test(before) && CLOSES.test(after))) return true;
   if (SQUARE_OPENED.test(before) && SQUARE_CLOSES.test(after) && spellsOut(body.slice(0, at), acronym)) return true;
-  return isSeparatedAt(body, acronym, at);
+  return isSeparatedAt(body, acronym, at) || isNamedBeforeAt(body, acronym, at) || isJointBracketedAt(body, acronym, at);
 };
 
+/**
+ * 記号を = で定義する書き方（where N = number of cases, EH = total hours worked）。定義は記号の後ろの語。
+ * 値（EH = 2,000）、比べる・矢印（==、=>）、別の略語だけ（EH = SRE）は定義ではない。定義の語は小文字か、大小の無い文字を含む。
+ * 語の値（SRE = enabled）は 1 語の定義と見分けられないので、定義と読む。値を入れる大文字の名前は設定の名前で、展開するものが無い。
+ */
+const EQUALS_DEFINITION = /^\s*[=＝]\s*(?=\p{L})\S*?[\p{Ll}\p{Lo}]/u;
+
+const isEqualsDefinedAt = (body: string, acronym: string, at: number): boolean =>
+  EQUALS_DEFINITION.test(body.slice(at + acronym.length, at + acronym.length + DEFINITION_REACH));
+
 export type ExpandedAt = (body: string, acronym: string, at: number) => boolean;
 
 /** body の at にある略語が、その場で展開・定義されているか。語彙表から一度だけ組み立てて、略語ごとに呼ぶ。 */
 export const expansionAt = (words: DefinitionWords): ExpandedAt => {
   const patterns = definitionPatterns(words);
-  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at);
+  return (body, acronym, at) => isBracketedAt(body, acronym, at) || isDefinedAt(patterns, body, acronym, at) || isEqualsDefinedAt(body, acronym, at);
 };

package/src/detectors/char-shape.ts

@@ -1,30 +1,70 @@
-import type { Detector, DocumentProfile, Finding, Sentence } from "../plugin.ts";
-import { compacted, placeOf } from "./gram-place.ts";
+import type { Detector, DocumentProfile, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { compacted } from "./gram-place.ts";
+import { leadingCounter } from "./counter-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
+import { isOneName } from "./name-run.ts";
 import { proseText } from "../measure.ts";
 import { parallelDotCount } from "./middle-dot.ts";
+import { maskSpans } from "../mask.ts";
+import { quotedSpans } from "../quoted-span.ts";
+import { nameSpans } from "../team-names.ts";
 
 /**
- * 文字の並びを見る検出。漢字の連なりが住所かどうかだけは、形態素解析の地名と数で決める。
+ * 文字の並びを見る検出。漢字の連なりが住所か名前かだけは、形態素解析の固有名詞と数で決める。
  * 覆った箇所は空白になっているので、proseText で潰してから数える。
  */
 const KANJI_RUN = /[一-鿿]+/gu;
 
-/** 漢字の連なりが住所か（東京都港区新橋二丁目）。形態素解析の地名と数で決める。品詞が無ければ判定しない。 */
-const isPlaceName = (sentence: Sentence, run: string, topUnits: ReadonlySet<string>): boolean => {
-  const tokens = sentence.tokens;
-  const place = tokens === undefined ? undefined : placeOf(compacted(sentence.text, "word"), run);
-  if (tokens === undefined || place === undefined) return false;
-  const [start, end] = [sentence.span.start + place.start, sentence.span.start + place.end];
-  const covering = tokens.flatMap((token, index) => (token.span.start < end && start < token.span.end ? [index] : []));
-  return isAddressRun(tokens, covering, topUnits);
+/** 漢字の連なりと、その文書全体の座標での範囲。quoted は鉤括弧の中身がまるごとこの連なりであること。 */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean };
+
+const SPACE = /\s/gu;
+
+/**
+ * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
+ * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
+ */
+/** 番地と、チームが並べた名前を空白で覆う。名前は読み手が 1 語と知っているので、前後は別の連なりになる。 */
+const maskedProse = (prose: string, profile: DocumentProfile | undefined, names: readonly string[]): string =>
+  maskSpans(maskAddresses(prose, profile), nameSpans(prose, names));
+
+/** 鉤括弧の中身が、ちょうどこの範囲（文の先頭からの位置）か。括弧でくくった漢字だけの語は、書き手が 1 つの名前として示したもの。 */
+const fillsQuote = (sentence: Sentence, start: number, end: number): boolean =>
+  quotedSpans(sentence.text).some((span) => span.start === start && span.end === end);
+
+const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names: readonly string[]): KanjiRun[] => {
+  const prose = proseText(sentence);
+  const printed = compacted(sentence.text, "char").offsets;
+  return [...maskedProse(prose, profile, names).matchAll(KANJI_RUN)].map((match) => {
+    const before = prose.slice(0, match.index).replace(SPACE, "").length;
+    const [start, last] = [printed[before], printed[before + match[0].length - 1]];
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false };
+    return { text: match[0], span: { start: sentence.span.start + start, end: sentence.span.start + last + 1 }, quoted: fillsQuote(sentence, start, last + 1) };
+  });
+};
+
+/** 漢字の連なりが住所（東京都港区新橋二丁目）か 1 つの名前（日本銀行）か。形態素解析の地名・人名・組織名と数で決める。 */
+const isPlaceName = (tokens: readonly Token[], span: Span, topUnits: ReadonlySet<string>): boolean => {
+  const covering = tokens.flatMap((token, index) => (token.span.start < span.end && span.start < token.span.end ? [index] : []));
+  return isAddressRun(tokens, covering, topUnits) || isOneName(tokens, covering);
+};
+
+/**
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）は数えない。
+ * 住所か名前かは、助数詞を外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
+ */
+const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, topUnits: ReadonlySet<string>): string => {
+  if (run.quoted) return "";
+  if (tokens === undefined || run.span === undefined) return run.text;
+  const counter = leadingCounter(tokens, run.span.start, run.text);
+  const rest = counter === undefined ? run.span : { start: counter.span.end, end: run.span.end };
+  return isPlaceName(tokens, rest, topUnits) ? "" : run.text.slice(counter?.surface.length ?? 0);
 };
 
-const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>): string =>
-  [...maskAddresses(proseText(sentence), profile).matchAll(KANJI_RUN)]
-    .map((match) => match[0])
-    .filter((run) => !isPlaceName(sentence, run, topUnits))
+const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined, topUnits: ReadonlySet<string>, names: readonly string[]): string =>
+  runsOf(sentence, profile, names)
+    .map((run) => measuredRun(sentence.tokens, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**
@@ -34,7 +74,7 @@ const longestKanji = (sentence: Sentence, profile: DocumentProfile | undefined,
 export const kanjiRun: Detector = (doc, options): Finding[] => {
   const topUnits = new Set((doc.lexicons["prefecture-unit"] ?? []).map((entry) => entry.pattern));
   return doc.sentences
-    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits) }))
+    .map((sentence) => ({ sentence, run: longestKanji(sentence, doc.profile, topUnits, doc.names ?? []) }))
     .filter(({ run }) => run.length > options.limit)
     .map(({ sentence, run }) => ({
       rule: "max-kanji-continuous",

package/src/detectors/citation-key.ts

@@ -0,0 +1,13 @@
+/**
+ * 仕様書が参考文献を指す角括弧の見出し語（[RFC9110]、[HPACK]、[SECURING-WEB]）。中身は文献一覧の見出しで、読み手はそこへ
+ * 飛ぶので、略語として展開を求めない。空白を含まない 1 語だけを見る。Markdown のリンク（[DRI](/url)、[DRI][ref]）と
+ * 参照の定義（[DRI]: /url）は括弧の後ろの記号で外し、その中の語は略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const CITATION_KEY = /(?<![\p{L}\p{N}_!\]])\[[A-Za-z][A-Za-z0-9.-]*[A-Za-z0-9]\](?![([:])/gu;
+
+/** 文の中の、参考文献の見出し語の範囲（括弧を含む）。 */
+export const citationKeySpans = (text: string): Span[] =>
+  [...text.matchAll(CITATION_KEY)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/cited-name.ts

@@ -0,0 +1,23 @@
+import type { StructureNode, Token } from "../plugin.ts";
+
+/** 他の文書を指す参照（民法第709条の第709条）の始まりの位置から、その文書の名前（民法）へ。 */
+export type CitedNames = ReadonlyMap<number, string>;
+
+const namedReferences = (node: StructureNode): (readonly [number, string])[] => {
+  const document = node.attrs["document"];
+  const own: (readonly [number, string])[] = node.kind === "reference" && typeof document === "string" ? [[node.span.start, document]] : [];
+  return [...own, ...node.children.flatMap(namedReferences)];
+};
+
+export const citedNamesOf = (structure: StructureNode | undefined): CitedNames => new Map(structure === undefined ? [] : namedReferences(structure));
+
+/** 略した名前は、頭の一字と種類の一字（所法・法法・措令）。二字の種類の語の重なり（規則規則）は略さない書き方。 */
+const ABBREVIATED_KIND_LENGTH = 1;
+
+/**
+ * 重なった二語が、番地のすぐ前に書いた文書の名前の全部で、頭の一字と種類の一字か。通達の「法法第64条」は法人税法の略で、
+ * 略した頭（法）と種類の語（法）がたまたま同じ字になる。名前の一部だけの重なり（就業規則規則第3条）や、種類の語でない語の
+ * 重なり（民法民法第709条）は書き損じのまま。
+ */
+export const endsCitedName = (first: Token, second: Token, cited: CitedNames, kinds: ReadonlySet<string>): boolean =>
+  kinds.has(second.surface) && [...second.surface].length === ABBREVIATED_KIND_LENGTH && cited.get(second.span.end) === `${first.surface}${second.surface}`;

package/src/detectors/concrete-evidence.ts

@@ -0,0 +1,31 @@
+import type { Span, StructureKind, StructureNode, Token } from "../plugin.ts";
+
+/**
+ * 形態素解析が数と読んだ語（UD の NumType=Card）。漢数字の「二割」「十五分」も、算用数字と同じ具体的な数。
+ * 言い回しの「二人三脚」「一人ひとり」は、辞書が一語として持つので数にならない。
+ */
+const isCardinal = (token: Token): boolean => token.features?.["NumType"] === "Card";
+
+const HYPHEN = /^[-‐‑]$/u;
+
+/** ハイフンで前の語に続く数（one-on-one の後ろの one）は、合成語の部品。 */
+const isCompoundPart = (token: Token, previous: Token | undefined): boolean =>
+  previous !== undefined && previous.span.end === token.span.start && HYPHEN.test(previous.surface);
+
+/** 数の語（UPOS の NUM）が、すぐ後ろの複数形の名詞を数えている（five minutes）。one of や two-way は量ではない。 */
+const countsPlural = (tokens: readonly Token[], index: number): boolean => {
+  const token = tokens[index];
+  return token?.pos === "NUM" && tokens[index + 1]?.features?.["Number"] === "Plur" && !isCompoundPart(token, tokens[index - 1]);
+};
+
+/** 品詞が無ければ何も言わない。数字そのものは呼ぶ側が文字で見る。 */
+export const hasNumeral = (tokens: readonly Token[]): boolean => tokens.some((token, index) => isCardinal(token) || countsPlural(tokens, index));
+
+/** 節の中で始まるものがある。節は見出しの直後から次の見出しの前まで。 */
+export const startsWithin = (section: Span, spans: readonly Span[]): boolean => spans.some((span) => span.start >= section.start && span.start < section.end);
+
+/** 構造の木が読んだ参照（第3条・Section VI）・数量・日付。どれも読み手が確かめに行ける具体物。 */
+const EVIDENCE: ReadonlySet<StructureKind> = new Set(["reference", "quantity", "date"]);
+
+export const evidenceSpans = (node: StructureNode | undefined): Span[] =>
+  node === undefined ? [] : [...(EVIDENCE.has(node.kind) ? [node.span] : []), ...node.children.flatMap((child) => evidenceSpans(child))];

package/src/detectors/counter-edge.ts

@@ -0,0 +1,29 @@
+import type { Token } from "../plugin.ts";
+
+const BLANK = /^\s+$/u;
+
+const isNumber = (token: Token | undefined): boolean => token?.features?.["NumType"] === "Card";
+const isCounter = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Class";
+
+const touches = (left: Token, right: Token): boolean => left.span.end === right.span.start;
+
+/** at の語のすぐ前の語。空白一つを挟んでもよい（「2 日」）。 */
+const wordBefore = (tokens: readonly Token[], at: number): Token | undefined => {
+  const [previous, token] = [tokens[at - 1], tokens[at]];
+  if (previous === undefined || token === undefined || !touches(previous, token)) return undefined;
+  if (!BLANK.test(previous.surface)) return previous;
+  const beyond = tokens[at - 2];
+  return beyond !== undefined && touches(beyond, previous) ? beyond : undefined;
+};
+
+/**
+ * 漢字の連なり run（文書全体の座標で start から始まる）の頭が、直前の数に付いた助数詞（2日、第76回、24時間）なら、その助数詞の語。
+ * 数字が区切りを見せるので、助数詞は数と読まれ、後ろの複合語の一部ではない。そうでなければ undefined。
+ * 折り返しをまたぐ語（年\n度）は span が surface より長いので、連なりの残りは span の終わりから始まる。
+ */
+export const leadingCounter = (tokens: readonly Token[], start: number, run: string): Token | undefined => {
+  const at = tokens.findIndex((token) => token.span.start === start);
+  const counter = tokens[at];
+  if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
+  return run.startsWith(counter.surface) ? counter : undefined;
+};

package/src/detectors/dotted-name.ts

@@ -0,0 +1,14 @@
+/**
+ * . で空白を挟まずに繋いだ語（GOV.UK、SAM.gov、README.md、ASP.NET）。ドメイン名やファイル名で、中の大文字は略語ではない。
+ * 文の終わりの . は後ろに空白か行末が来る（…by the IRS. Then）ので、ここには当たらない。空白を落とした文の境目
+ * （the IRS.Then、Mr.HAWLEY）は頭だけ大文字の部品で分かるので、部品は全部大文字か全部小文字（と数字）に限る。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+const LABEL = "(?:[A-Z0-9][A-Z0-9-]*|[a-z0-9][a-z0-9-]*)";
+const DOTTED_NAME = new RegExp(String.raw`(?<![A-Za-z0-9_&.-])${LABEL}(?:\.${LABEL})+(?![A-Za-z0-9_&])`, "gu");
+
+/** 文の中の、. で繋いだ名前の範囲。 */
+export const dottedNameSpans = (text: string): Span[] =>
+  [...text.matchAll(DOTTED_NAME)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/doubled-word.ts

@@ -1,4 +1,5 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
+import { citedNamesOf, endsCitedName } from "./cited-name.ts";
 
 /**
  * 語を書き損じて二度書いた（the the / 資料をを）。消し忘れと、書き換えの途中で残った語（our the platform）の二つ。
@@ -99,11 +100,22 @@ const repeatsPrevious = (tokens: readonly Token[], at: number): boolean => {
 /** 語彙表の重なり（had had）も、三つ続けば（had had had）書き損じ。 */
 const allowedAt = (tokens: readonly Token[], at: number, allowed: Lexicon): Lexicon => (repeatsPrevious(tokens, at) ? [] : allowed);
 
-export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon): Doubled[] =>
+/**
+ * tokens の at 語目から、語彙表の決まった句（a priori・a la carte）が始まるか。句の頭の a は冠詞ではなく句の一部なので、
+ * 前の違う冠詞と並んでも（the a priori approach）書き損じではない。同じ語（a a priori）は書き損じのまま。
+ */
+export const opensPhrase = (tokens: readonly Token[], at: number, phrases: Lexicon): boolean =>
+  phrases.some((entry) => {
+    const words = entry.tokens ?? [];
+    return words.length > 1 && surfacesOf(tokens.slice(at, at + words.length)) === surfacesOf(words);
+  });
+
+export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon, phrases: Lexicon = []): Doubled[] =>
   tokens.flatMap((second, index) => {
     const first = tokens[index - 1];
     if (first === undefined || !doubledAt(source, first, second, spaced)) return [];
     if (isAllowed(tokens, index - 1, allowedAt(tokens, index - 1, allowed))) return [];
+    if (!sameWord(first, second) && opensPhrase(tokens, index, phrases)) return [];
     return isNameBefore(first, second, opensSentence(tokens, index - 1)) ? [] : [{ first, second }];
   });
 
@@ -119,10 +131,21 @@ const findingOf = (sentence: Sentence, doubled: Doubled, spaced: boolean): Findi
   values: { word: wordOf(doubled, spaced), offset: doubled.second.span.start },
 });
 
+/** 文書の種類の語（法・規則・契約書）。語彙表はアダプタが持つ。 */
+const DOCUMENT_KIND = "document-kind";
+
+/** 冠詞のような語で始まる決まった句。語彙表はアダプタが持つ。冠詞の無い言語（日本語）は持たない。 */
+const FIXED_PHRASE = "fixed-phrase";
+
 export const doubledWord: Detector = (doc, options): Finding[] => {
   const spaced = doc.lengthUnit === "word";
   const allowed = options.lexicon ?? [];
+  const cited = citedNamesOf(doc.structure);
+  const kinds = new Set((doc.lexicons[DOCUMENT_KIND] ?? []).map((entry) => entry.pattern));
+  const phrases = doc.lexicons[FIXED_PHRASE] ?? [];
   return doc.sentences.flatMap((sentence) =>
-    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed).map((doubled) => findingOf(sentence, doubled, spaced)),
+    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases)
+      .filter((doubled) => !endsCitedName(doubled.first, doubled.second, cited, kinds))
+      .map((doubled) => findingOf(sentence, doubled, spaced)),
   );
 };