chaffjs 0.13.0 → 0.15.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,29 +1,58 @@
-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";
 
 /**
- * 文字の並びを見る検出。漢字の連なりが住所かどうかだけは、形態素解析の地名と数で決める。
+ * 文字の並びを見る検出。漢字の連なりが住所か名前かだけは、形態素解析の固有名詞と数で決める。
  * 覆った箇所は空白になっているので、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);
+/** 漢字の連なりと、その文書全体の座標での範囲。 */
+type KanjiRun = { readonly text: string; readonly span: Span | undefined };
+
+const SPACE = /\s/gu;
+
+/**
+ * 同じ連なりが文に二度出ても、それぞれの位置で読む。proseText は空白を詰めたり除いたりするだけなので、
+ * 空白でない k 文字目は元の文でも空白でない k 文字目。番地の覆いは長さを保つので、proseText の位置がそのまま使える。
+ */
+const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined): KanjiRun[] => {
+  const prose = proseText(sentence);
+  const printed = compacted(sentence.text, "char").offsets;
+  return [...maskAddresses(prose, profile).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]];
+    const span = start === undefined || last === undefined ? undefined : { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
+    return { text: match[0], span };
+  });
+};
+
+/** 漢字の連なりが住所（東京都港区新橋二丁目）か 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 (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))
+  runsOf(sentence, profile)
+    .map((run) => measuredRun(sentence.tokens, run, topUnits))
     .reduce((longest, run) => (run.length > longest.length ? run : longest), "");
 
 /**
@@ -45,15 +74,13 @@ export const kanjiRun: Detector = (doc, options): Finding[] => {
     }));
 };
 
-const MIDDLE_DOT = /・/gu;
-
 /**
  * 中黒で並べると、どこまでが 1 つの項目か分からなくなる。
  * 「企画・開発・運用・保守体制」は、保守体制が 1 つなのか保守と体制なのか読めない。
  */
 export const middleDot: Detector = (doc, options): Finding[] =>
   doc.sentences
-    .map((sentence) => ({ sentence, count: [...proseText(sentence).matchAll(MIDDLE_DOT)].length }))
+    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text) }))
     .filter(({ count }) => count > options.limit)
     .map(({ sentence, count }) => ({
       rule: "no-nakaguro-parallel",

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/conjugated-form.ts

@@ -0,0 +1,40 @@
+import type { Sentence, Token } from "../plugin.ts";
+
+/**
+ * 語彙表が原形で書いた語句（という、と呼ぶ）が、文の中で活用して書かれた形（といいます、と呼びました）。
+ * 語句の最後の動詞を原形（lemma）で照らし、その前の部分は字面で照らす。語句を語に分けて並びで照らさないのは、
+ * 解析器が単独の「という」を 1 つの助詞に、「といいます」を と・いい・ます に分け、「称し」の原形を 称す とするから。
+ * 活用した形は、動詞に続く助動詞（ます、た）まで。品詞が無い文からは何も出ない。
+ */
+
+type Run = { readonly start: number; readonly end: number };
+
+/** 動詞と、そのすぐ後ろに続く助動詞の、文の中の範囲。 */
+const inflectedRun = (sentence: Sentence, tokens: readonly Token[], index: number, verb: Token): Run => {
+  const rest = tokens.slice(index + 1);
+  const stop = rest.findIndex((token) => token.pos !== "AUX");
+  const last = (stop === -1 ? rest : rest.slice(0, stop)).at(-1) ?? verb;
+  return { start: verb.span.start - sentence.span.start, end: last.span.end - sentence.span.start };
+};
+
+const formsAt = (sentence: Sentence, tokens: readonly Token[], index: number, bases: readonly string[]): string[] => {
+  const verb = tokens[index];
+  const lemma = verb?.lemma;
+  if (verb?.pos !== "VERB" || lemma === undefined || lemma === "") return [];
+  const run = inflectedRun(sentence, tokens, index, verb);
+  const before = sentence.text.slice(0, run.start);
+  const written = sentence.text.slice(run.start, run.end);
+  return bases
+    .filter((base) => base.endsWith(lemma))
+    .map((base) => base.slice(0, base.length - lemma.length))
+    .filter((head) => before.endsWith(head))
+    .map((head) => `${head}${written}`);
+};
+
+export const conjugatedForms = (sentences: readonly Sentence[], bases: readonly string[]): string[] => {
+  const forms = sentences.flatMap((sentence) => {
+    const tokens = sentence.tokens ?? [];
+    return tokens.flatMap((_token, index) => formsAt(sentence, tokens, index, bases));
+  });
+  return [...new Set(forms)];
+};

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

package/src/detectors/en-shape.ts

@@ -1,5 +1,6 @@
 import { lengthOf } from "../measure.ts";
 import { isClosed } from "../sentence-shape.ts";
+import { isTitleCase, minorityCase, pageTitleOf } from "./heading-case.ts";
 import type { Detector, Finding, ProseDocument, Section, Sentence, Token } from "../plugin.ts";
 
 const PER = 1000;
@@ -106,19 +107,6 @@ export const conjunctionRun: Detector = (doc, options): Finding[] => {
     });
 };
 
-const WORD = /[A-Za-z][A-Za-z'-]*/gu;
-
-/** 小さい語は Title Case でも小文字のままなので、大文字化の判定から外す。 */
-const MINOR = new Set(["a", "an", "the", "and", "or", "but", "of", "in", "on", "at", "to", "for", "with", "as", "by", "from", "is"]);
-
-const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()));
-  // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
-  if (words.length < 2) return undefined;
-  const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;
-  return capitalized === words.length;
-};
-
 const headingsOf = (sections: readonly Section[]): { readonly section: Section; readonly title: boolean }[] =>
   sections.flatMap((section) => {
     const title = isTitleCase(section.heading);
@@ -127,25 +115,24 @@ const headingsOf = (sections: readonly Section[]): { readonly section: Section;
 
 /**
  * 見出しの大文字化が混ざっている。どちらの流儀が正しいかは決めない。spec §12.3。
- * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。
+ * 見るのは文書の中で揃っているかだけで、少数派のほうを指摘する。題名は指摘しない（minorityCase）。
  */
 export const titleCaseMix: Detector = (doc, options): Finding[] => {
-  const judged = headingsOf(doc.sections);
-  const title = judged.filter((entry) => entry.title).length;
-  const minorityIsTitle = title <= judged.length - title;
-  const few = minorityIsTitle ? title : judged.length - title;
-  // 同数なら少数派は無い。どちらかを「他と違う」と呼ぶのは、選びかたが恣意的になる。
-  if (few === 0 || few * 2 === judged.length || few > options.limit) return [];
-  return judged
-    .filter((entry) => entry.title === minorityIsTitle)
-    .map(({ section }) => ({
-      rule: "title-case-consistency",
-      severity: "info",
-      line: 0,
-      column: 0,
-      quote: section.heading,
-      values: { count: few, limit: options.limit, offset: section.span.start },
-    }));
+  const pageTitle = pageTitleOf(doc.sections);
+  const judged = headingsOf(doc.sections.filter((section) => section !== pageTitle));
+  const titleCase = judged.filter((entry) => entry.title).length;
+  const pageTitleCase = pageTitle === undefined ? undefined : isTitleCase(pageTitle.heading);
+  const minorityIsTitle = minorityCase({ titleCase, sentenceCase: judged.length - titleCase }, pageTitleCase);
+  const few = minorityIsTitle === undefined ? [] : judged.filter((entry) => entry.title === minorityIsTitle);
+  if (few.length > options.limit) return [];
+  return few.map(({ section }) => ({
+    rule: "title-case-consistency",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: section.heading,
+    values: { count: few.length, limit: options.limit, offset: section.span.start },
+  }));
 };
 
 const LIST_CONJUNCTION = new Set(["and", "or"]);

package/src/detectors/enumerated-runs.ts

@@ -0,0 +1,68 @@
+import type { Sentence, Span, StructureNode, Token } from "../plugin.ts";
+
+/** 番号の付いた行。start は行の始まり（字下げの前）、label は言語パッケージが読んだ番号（「（1）」）。 */
+export type NumberedStart = { readonly start: number; readonly label: string };
+
+const labelOf = (node: StructureNode): string => {
+  const label = node.attrs["label"];
+  return typeof label === "string" ? label : "";
+};
+
+/**
+ * 条の外で、番号の付いた行（言語パッケージが項目と読んだ「（1）」など）。
+ * 条の中の番号付きの行は、条の項（条の本文の続き）でもありうるので数えない。
+ */
+export const numberedStarts = (node: StructureNode, inArticle = false): NumberedStart[] => [
+  ...(node.kind === "item" && !inArticle ? [{ start: node.span.start, label: labelOf(node) }] : []),
+  ...node.children.flatMap((child) => numberedStarts(child, inArticle || node.kind === "article")),
+];
+
+const INDENT = /^[ \t\u3000]*/u;
+
+const lineAt = (source: string, start: number): string => {
+  const end = source.indexOf("\n", start);
+  return source.slice(start, end === -1 ? source.length : end);
+};
+
+/** 番号の直後の語。字下げと番号と空白を飛ばした先の、最初の語。 */
+const wordAfter = (numbered: NumberedStart, sentences: readonly Sentence[], source: string): Token | undefined => {
+  const after = numbered.start + (INDENT.exec(lineAt(source, numbered.start))?.[0].length ?? 0) + numbered.label.length;
+  const sentence = sentences.find((candidate) => candidate.span.end > after);
+  return sentence?.tokens?.find((token) => token.span.start >= after && token.surface.trim() !== "");
+};
+
+/**
+ * 並びの項目として番号を振った行の始まり。番号の直後が助詞（「（1）の金額は」「（2）は対象外」）なら、
+ * 番号は項目の印ではなく、項目を指す本文の主語や修飾なので除く。
+ */
+export const enumeratorStarts = (numbered: readonly NumberedStart[], sentences: readonly Sentence[], source: string): number[] =>
+  numbered.filter((line) => wordAfter(line, sentences, source)?.pos !== "ADP").map((line) => line.start);
+
+/** 番号の付いた行の始まりと段落の始まりのあいだが字下げだけなら、段落はその行から始まる。 */
+const opensWithItem = (paragraph: Span, starts: readonly number[], source: string): boolean =>
+  starts.some((start) => start <= paragraph.start && source.slice(start, paragraph.start).trim() === "");
+
+const isBlank = (source: string, from: number, to: number): boolean => source.slice(from, to).trim() === "";
+
+/** 並びと読むのに要る、番号の付いた行の数。一つだけなら、並びではなく番号で始まる本文の段落かもしれない。 */
+const MIN_ITEMS = 2;
+
+/** 番号の行の始まりは字下げの前なので、並びの最初の行の頭から数える。 */
+const itemsIn = (run: Span, starts: readonly number[], source: string): number => {
+  const lineStart = source.lastIndexOf("\n", run.start - 1) + 1;
+  return starts.filter((start) => start >= lineStart && start < run.end).length;
+};
+
+/**
+ * 番号で始まる段落が、空行だけを挟んで続く範囲。番号の付いた行を二つ以上含むものだけ。
+ * 要件や条件を「（1）…であること。」と並べるのは、段落でも箇条書きと同じ書き方で、本文の調子とは別に揃える。
+ */
+export const enumeratedRuns = (paragraphs: readonly Span[], starts: readonly number[], source: string): Span[] => {
+  const enumerated = paragraphs.filter((paragraph) => opensWithItem(paragraph, starts, source));
+  const runs = enumerated.reduce<Span[]>((joined, paragraph) => {
+    const last = joined.at(-1);
+    if (last === undefined || !isBlank(source, last.end, paragraph.start)) return [...joined, paragraph];
+    return [...joined.slice(0, -1), { start: last.start, end: paragraph.end }];
+  }, []);
+  return runs.filter((run) => itemsIn(run, starts, source) >= MIN_ITEMS);
+};

package/src/detectors/gram-place.ts

@@ -1,3 +1,4 @@
+import { softBreaks } from "../soft-break.ts";
 import type { LengthUnit, Span } from "../plugin.ts";
 
 /** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
@@ -7,15 +8,21 @@ export type Compacted = { readonly text: string; readonly offsets: readonly numb
  * n-gram を数えるときと同じ詰め方。word 単位は空白の並びを 1 つにして前後を削り、char 単位は空白を全部除く。
  * 語句が元の文のどこにあるかを戻せるよう、残した文字ごとに元の位置を持つ。
  */
+/** spans が覆う位置（UTF-16 の単位）。 */
+const offsetsIn = (spans: readonly Span[]): Set<number> =>
+  new Set(spans.flatMap((span) => Array.from({ length: span.end - span.start }, (_, step) => span.start + step)));
+
 export const compacted = (text: string, unit: LengthUnit): Compacted => {
   const chars: string[] = [];
   const offsets: number[] = [];
   const state = { pendingSpace: -1, at: 0 };
+  // 読み手に見えない改行は空白 1 つにもしない。proseText がつないだ語句を、ここでも同じ形で探せるように。
+  const hidden = offsetsIn(unit === "word" ? softBreaks(text) : []);
   Array.from(text).forEach((char) => {
     const at = state.at;
     state.at += char.length;
     if (/\s/u.test(char)) {
-      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1) state.pendingSpace = at;
+      if (unit === "word" && chars.length > 0 && state.pendingSpace === -1 && !hidden.has(at)) state.pendingSpace = at;
       return;
     }
     if (state.pendingSpace !== -1) {