chaffjs 0.35.0 → 0.36.0

package/src/detectors/field-label.ts

@@ -0,0 +1,25 @@
+// The label of a field that opens a line ("Current project status: Ongoing", 「現在の状況：継続中」). Pure.
+
+/** A label is a short name, not a clause: this many words at most. */
+const MAX_LABEL_WORDS = 5;
+const MAX_LABEL_CHARS = 40;
+const LIST_MARKER = /^\s*(?:[-*+]|\d+[.)])\s+/u;
+const FIELD = /^([^:：\n]+)[:：](?!\/\/)/u;
+const HAS_LETTER = /\p{L}/u;
+/** A sentence ends before the colon, so what precedes it is not a label. */
+const SENTENCE_END = /[.!?。！？]/u;
+
+const isLabel = (label: string): boolean =>
+  HAS_LETTER.test(label) && !SENTENCE_END.test(label) && label.length <= MAX_LABEL_CHARS && label.trim().split(/\s+/u).length <= MAX_LABEL_WORDS;
+
+/**
+ * Where the value of a field on the text's first line starts, just past the colon (the value may be blank), or undefined
+ * when the first line opens with no label. Whether the label is a name and not a clause ("The following apply:") is the
+ * caller's to judge from the parts of speech.
+ */
+export const fieldValueStart = (text: string): number | undefined => {
+  const marker = LIST_MARKER.exec(text)?.[0] ?? "";
+  const field = FIELD.exec(text.slice(marker.length));
+  if (field?.[1] === undefined || !isLabel(field[1].replaceAll("**", ""))) return undefined;
+  return marker.length + field[0].length;
+};

package/src/detectors/footnote-mismatch.ts

@@ -26,9 +26,12 @@ const markdownMarks = (text: string): NoteMark[] =>
     return { offset: match.index, label: `[^${match.groups?.["key"] ?? ""}]`, kind: MARKDOWN, key: (match.groups?.["key"] ?? "").toLowerCase(), note };
   });
 
-/** 印と一桁か二桁の番号。後ろに数字や小数が続けば年や数（※2018年度、※1.2倍）で、注の番号ではない。 */
+/** 番号の後ろに続くと、番号が英語の序数（1st、2nd、23rd）になるもの。 */
+const ORDINAL_SUFFIX = "(?:[sS][tT]|[nN][dD]|[rR][dD]|[tT][hH])(?![A-Za-z])";
+
+/** 印と一桁か二桁の番号。後ろに数字や小数が続けば年や数（※2018年度、※1.2倍）、序数が続けば英語の語（※1st Party）で、注の番号ではない。 */
 const wordMarks = (text: string, mark: string): NoteMark[] =>
-  [...text.matchAll(new RegExp(`${escapeRegExp(mark)}(?<key>[0-9０-９]{1,2})(?![0-9０-９]|[.．,，][0-9０-９])`, "gu"))].map((match) => ({
+  [...text.matchAll(new RegExp(`${escapeRegExp(mark)}(?<key>[0-9０-９]{1,2})(?![0-9０-９]|[.．,，][0-9０-９]|${ORDINAL_SUFFIX})`, "gu"))].map((match) => ({
     offset: match.index,
     label: match[0],
     kind: mark,
@@ -36,11 +39,38 @@ const wordMarks = (text: string, mark: string): NoteMark[] =>
     note: NOTE_LINE_HEAD.test(lineHeadOf(text, match.index)),
   }));
 
+const QUOTE_LINE = /^[ \t]{0,3}>/u;
+const QUOTE_MARKS = /^(?:[ \t]{0,3}>)+/u;
+/** 引用の段落を終わらせる行（見出し、コード、箇条書き、脚注の定義）。これ以外の空でない行は、引用の段落の続き（CommonMark の lazy continuation）。 */
+const BLOCK_START = /^[ \t]{0,3}(?:[#`~]|[-*+][ \t]|\d{1,9}[.)][ \t]|\[\^)/u;
+const CODE_SPAN = /(`+)[\s\S]*?\1/gu;
+
+const quotedLines = (source: string): string[] =>
+  source.split("\n").reduce<{ lines: string[]; open: boolean }>(
+    (state, line) => {
+      const open = QUOTE_LINE.test(line) || (state.open && line.trim() !== "" && !BLOCK_START.test(line));
+      return { lines: open ? [...state.lines, line.replace(QUOTE_MARKS, "")] : state.lines, open };
+    },
+    { lines: [], open: false },
+  ).lines;
+
+/**
+ * 引用（`>`）の中の Markdown の脚注の印の番号。引用は本文から覆われるが、引用の中の印も注を指している。
+ * 引用の中の印に注が無くても言わない（引用元の注かもしれない）。注が指されているかだけに使う。
+ */
+export const quotedFootnoteKeys = (source: string): ReadonlySet<string> =>
+  new Set(
+    markdownMarks(quotedLines(source).join("\n").replace(CODE_SPAN, ""))
+      .filter((mark) => !mark.note)
+      .map((mark) => mark.key),
+  );
+
 /** 一つの種類の印のうち、合わないもの。印の語（※）は、その種類の注が一つも無ければ注を別に置いた文書と読んで言わない。 */
-const slipsOfKind = (marks: readonly NoteMark[], kind: string): NoteSlip[] => {
+const slipsOfKind = (marks: readonly NoteMark[], kind: string, quotedKeys: ReadonlySet<string>): NoteSlip[] => {
   const ofKind = marks.filter((mark) => mark.kind === kind);
   const notes = new Set(ofKind.filter((mark) => mark.note).map((mark) => mark.key));
-  const referenced = new Set(ofKind.filter((mark) => !mark.note).map((mark) => mark.key));
+  const quoted = kind === MARKDOWN ? [...quotedKeys] : [];
+  const referenced = new Set([...ofKind.filter((mark) => !mark.note).map((mark) => mark.key), ...quoted]);
   if (notes.size === 0 && kind !== MARKDOWN) return [];
   const missing = ofKind
     .filter((mark) => !mark.note && !notes.has(mark.key))
@@ -52,15 +82,17 @@ const slipsOfKind = (marks: readonly NoteMark[], kind: string): NoteSlip[] => {
 };
 
 /** 文字列の中の、注の無い印と印の無い注。 */
-export const noteSlips = (text: string, words: readonly string[]): NoteSlip[] => {
+export const noteSlips = (text: string, words: readonly string[], quotedKeys: ReadonlySet<string> = new Set()): NoteSlip[] => {
   const marks = [...markdownMarks(text), ...words.flatMap((word) => wordMarks(text, word))];
-  return [...new Set(marks.map((mark) => mark.kind))].flatMap((kind) => slipsOfKind(marks, kind)).toSorted((left, right) => left.offset - right.offset);
+  return [...new Set(marks.map((mark) => mark.kind))]
+    .flatMap((kind) => slipsOfKind(marks, kind, quotedKeys))
+    .toSorted((left, right) => left.offset - right.offset);
 };
 
 export const footnoteMismatch: Detector = (doc): Finding[] => {
   const text = doc.prose ?? doc.source;
   const words = (doc.lexicons["note-mark"] ?? []).map((entry) => entry.pattern);
-  return noteSlips(text, words).map((slip) => ({
+  return noteSlips(text, words, quotedFootnoteKeys(doc.source)).map((slip) => ({
     rule: "",
     severity: "warning",
     line: 0,

package/src/detectors/graded-step.ts

@@ -0,0 +1,52 @@
+import type { Span, Token } from "../plugin.ts";
+import { isWithinAny } from "../quoted-span.ts";
+
+/**
+ * 段階の一つとしての比較（より良い（BESTな）改善 と 良い（BETTERな）改善、より良い実装例1 と 良い実装例2）。文書が同じ語を
+ * 比べる副詞なしでも書いていれば（良い改善）、「より良い」の相手はその一段下の段で、相手は書いてある。
+ * 段は、程度を言う語の原形と、その後ろの名詞で見分ける。間の括弧の添え書き（（BESTな））は飛ばす。
+ */
+
+/** 程度を言う語が語の位置 at で始まるか。bare-comparative.ts の判定を受け取る。 */
+export type IsGradable = (tokens: readonly Token[], at: number) => boolean;
+
+/** 形容動詞の語幹の後ろに来る語（豊かな）。この語の後ろから名詞を探す。 */
+const ADJECTIVAL_TAIL = new Set(["な", "に", "だ", "です", "で"]);
+const OPENING = new Set(["（", "("]);
+const CLOSING = new Set(["）", ")"]);
+
+/** 程度を言う語（at）の後ろの最初の語の位置。形容動詞の語尾と、括弧の添え書きを飛ばす。 */
+const afterWord = (tokens: readonly Token[], at: number): number => {
+  const next = tokens[at]?.pos === "NOUN" && ADJECTIVAL_TAIL.has(tokens[at + 1]?.surface ?? "") ? at + 2 : at + 1;
+  if (!OPENING.has(tokens[next]?.surface ?? "")) return next;
+  const close = tokens.findIndex((token, index) => index > next && CLOSING.has(token.surface));
+  return close === -1 ? next : close + 1;
+};
+
+/** 段の名前: 程度を言う語の原形と、後ろの名詞。後ろが名詞でなければ段ではない。 */
+export const stepKeyAt = (tokens: readonly Token[], at: number): string | undefined => {
+  const [word, noun] = [tokens[at], tokens[afterWord(tokens, at)]];
+  if (word === undefined || noun === undefined || noun.pos !== "NOUN") return undefined;
+  return `${word.lemma ?? word.surface}|${noun.surface}`;
+};
+
+/** 文の語と、引いたもの（鉤括弧の中）の範囲。引いた語（「良い対応」という表現）は文書が書いた段ではない。 */
+export type StepSentence = { readonly tokens: readonly Token[]; readonly quoted: readonly Span[] };
+
+/** 文書が比べる副詞（markers）なしで書いた、程度を言う語と名詞の段の名前。 */
+export const plainStepKeys = (sentences: readonly StepSentence[], markers: ReadonlySet<string>, isGradable: IsGradable): ReadonlySet<string> =>
+  new Set(
+    sentences.flatMap(({ tokens, quoted }) =>
+      tokens.flatMap((token, at) => {
+        if (markers.has(tokens[at - 1]?.surface ?? "") || isWithinAny(quoted, token.span) || !isGradable(tokens, at)) return [];
+        const key = stepKeyAt(tokens, at);
+        return key === undefined ? [] : [key];
+      }),
+    ),
+  );
+
+/** 比べた語（word）が、文書が一段下を書いた段の一つか。 */
+export const isNamedStep = (tokens: readonly Token[], word: Token, steps: ReadonlySet<string>): boolean => {
+  const key = stepKeyAt(tokens, tokens.indexOf(word));
+  return key !== undefined && steps.has(key);
+};

package/src/detectors/gram-openers.ts

@@ -0,0 +1,21 @@
+import type { Section, Sentence } from "../plugin.ts";
+
+/** A list item or a table row on a line after the sentence: what the sentence leads into. */
+const LIST_OR_TABLE_NEXT = /^[ \t]*\n\s*(?:[-*+]\s|\d{1,3}[.)]\s|\|)/u;
+
+/** How far past the sentence to look for that line: blank lines between, never the rest of a long document. */
+const LOOKAHEAD = 200;
+
+/**
+ * 見出しのある節の最初の文のうち、次の行から箇条書きか表が続くもの。参照用の文書は、節ごとに同じ書き出しで一覧を導く
+ * （「…によると以下の制約である。」の後ろに制約の箇条書き）。言い回しがどれもこの文にだけ出るなら節のひな形で、書き手が言い直したのではない。
+ * 後ろが本文の文なら、節ごとの口癖（正直なところ、…）と見分けられないので入れない。導入部（見出しの前）は節ではない。
+ */
+export const sectionOpeners = (sections: readonly Pick<Section, "depth" | "sentences">[], source: string): Set<Sentence> =>
+  new Set(
+    sections.flatMap((section) => {
+      const first = section.sentences[0];
+      if (section.depth === 0 || first === undefined) return [];
+      return LIST_OR_TABLE_NEXT.test(source.slice(first.span.end, first.span.end + LOOKAHEAD)) ? [first] : [];
+    }),
+  );

package/src/detectors/gram-place.ts

@@ -1,5 +1,5 @@
 import { softBreaks } from "../soft-break.ts";
-import type { LengthUnit, Span } from "../plugin.ts";
+import type { LengthUnit, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /** 数えるために詰めた文と、詰めた文の各文字が元の文のどこにあったか。 */
 export type Compacted = { readonly text: string; readonly offsets: readonly number[] };
@@ -50,3 +50,12 @@ export const placeOf = (source: Compacted, gram: string): Span | undefined => {
   const at = source.text.indexOf(gram);
   return at === -1 ? undefined : placeAt(source, { start: at, end: at + gram.length });
 };
+
+/** 詰めた文の index 番目の文字が、リンクの文字か。 */
+export const linkedIn = (doc: ProseDocument, sentence: Sentence, source: Compacted): ((index: number) => boolean) => {
+  const links = doc.links.filter((link) => link.start < sentence.span.end && sentence.span.start < link.end);
+  return (index) => {
+    const at = sentence.span.start + (source.offsets[index] ?? -1);
+    return links.some((link) => link.start <= at && at < link.end);
+  };
+};

package/src/detectors/gram-predicate.ts

@@ -9,12 +9,28 @@ const NOUNS = new Set(["NOUN", "PROPN", "ADJ"]);
 /** 中身を持たない語。名前の前後に付いても、名前の繰り返しを言い回しに変えない。 */
 const FUNCTION_POS = new Set(["ADP", "DET", "CCONJ", "SCONJ", "PART", "PUNCT", "SYM", "X"]);
 
+/** 形式名詞（とき、こと）。動詞が節を名詞にしているだけで、用語は作らない（承認又は断るとき）。 */
+const isDependentNoun = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Dependent";
+
+/**
+ * 日本語で、名詞と接続詞（又は、及び）のすぐ後ろで名詞を飾る動詞（行為又は怠る事実）は、名詞を並べた一つの用語の中にあり、述語ではない。
+ * 用語は言い換えられないので、繰り返して当たり前。名詞に「する」が付いた動詞（承認又は拒否する）は、行為を並べた述語と見分けられないので外さない。
+ */
+const inCoordinatedNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
+  unit === "char" &&
+  tokens[index]?.pos === "VERB" &&
+  tokens[index]?.features?.["VerbType"] !== "Light" &&
+  tokens[index - 1]?.pos === "CCONJ" &&
+  NOUNS.has(tokens[index - 2]?.pos ?? "") &&
+  NOUNS.has(tokens[index + 1]?.pos ?? "") &&
+  !isDependentNoun(tokens[index + 1]);
+
 /**
  * 英語で名詞のすぐ前の動詞は、名詞を飾る語（形容詞を挟んでも同じ）（the upcoming fiscal year、the Disclosing Party、the borrow checker）で、
- * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、word 単位だけで見る。
+ * 述語ではない。日本語の名詞の前の動詞（〜にあるコンポーネント）は言い回しの一部になるので、接続詞の後ろの用語の中（inCoordinatedNoun）だけを外す。
  */
 const modifiesNoun = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean =>
-  unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "");
+  (unit === "word" && tokens[index]?.pos === "VERB" && NOUNS.has(tokens[index + 1]?.pos ?? "")) || inCoordinatedNoun(tokens, index, unit);
 
 /** 英語で大文字の名前の一部になった動詞（Procedures Guide、the Location Object）も、述語ではない。 */
 const namePartAt = (tokens: readonly Token[], index: number, unit: LengthUnit): boolean => unit === "word" && isNamePart(tokens, index);
@@ -40,10 +56,34 @@ const onlyNamesBeside = (tokens: readonly Token[], predicate: number, window: Sp
   return names.length > 0 && rest.every((index) => FUNCTION_POS.has(tokens[index]?.pos ?? ""));
 };
 
+const COMPOUND_POS = new Set(["NOUN", "PROPN", "ADJ", "NUM"]);
+/** 動詞の前の名詞句がこれだけの語を持てば、動詞はその名詞句の最後の名詞。the contract says は 1 語なので述語のまま。 */
+const MIN_COMPOUND_WORDS = 2;
+
+/** 語形を変えていない動詞（rate）か -ing 形（subcontracting）。名詞と同じ形で、名詞の読み違いになりうる。described や says は述語の形。 */
+const isNounShaped = (token: Token): boolean =>
+  token.features?.["VerbForm"] === "Ger" || (token.lemma !== undefined && token.lemma === token.surface.toLowerCase());
+
+/** 動詞の目的語の始まり（models generate the text の the）。後ろにこれが続く動詞は述語。 */
+const OBJECT_START = new Set(["DET", "PRON", "NUM"]);
+
+/**
+ * 英語で、窓の最後の名詞の形の動詞の前が名詞と形容詞だけ（先頭の冠詞は許す）で、後ろに目的語が続かなければ、動詞は名詞の続きの
+ * 読み違い（the federal funds rate の rate、small business subcontracting）。窓の中に機能語があれば言い回し（your contract says）。
+ */
+const endsNounCompound = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
+  const verb = tokens[index];
+  if (unit !== "word" || verb?.pos !== "VERB" || !isNounShaped(verb) || OBJECT_START.has(tokens[index + 1]?.pos ?? "")) return false;
+  const touched = tokens.flatMap((token, at) => (overlaps(token, window) ? [at] : []));
+  if (touched.at(-1) !== index) return false;
+  const before = touched.slice(0, -1).filter((at, order) => !(order === 0 && tokens[at]?.pos === "DET"));
+  return before.length >= MIN_COMPOUND_WORDS && before.every((at) => COMPOUND_POS.has(tokens[at]?.pos ?? ""));
+};
+
 const countsAsPredicate = (tokens: readonly Token[], index: number, window: Span, unit: LengthUnit): boolean => {
   const token = tokens[index];
   if (token === undefined || !PREDICATE_POS.has(token.pos) || !overlaps(token, window)) return false;
-  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit)) return false;
+  if (modifiesNoun(tokens, index, unit) || namePartAt(tokens, index, unit) || endsNounCompound(tokens, index, window, unit)) return false;
   return !isCut(token, window) || !onlyNamesBeside(tokens, index, window, unit);
 };
 

package/src/detectors/heading-echo.ts

@@ -1,13 +1,15 @@
 import { lengthOf, proseText } from "../measure.ts";
 import { newContentMorphemes } from "./content-morphemes.ts";
 import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { fieldValueStart } from "./field-label.ts";
 import { formValueTokens, isFormBlock } from "./form-line.ts";
 import { titleTokens } from "../heading-label.ts";
 import { announcerWords, makesClaim } from "./heading-claim.ts";
 import { handsOver } from "./lead-in.ts";
 import { holdsLink, namesLocation } from "./location-pointer.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
-import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
+import { namesHeadingSubject } from "./subject-name-line.ts";
+import type { Detector, Finding, LengthUnit, ProseDocument, Section, Sentence } from "../plugin.ts";
 
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
@@ -105,8 +107,33 @@ const opensForm = (section: Section): boolean => {
   return newContentMorphemes(heading, formValueTokens(first.text, first.span.start, first.tokens)) > 0;
 };
 
+/** 最初の行が、見出しが扱うものの名前だけ（リンクや添付の札、見出しの名の一覧）。見出しを言い直す文ではない。 */
+const namesSubject = (doc: ProseDocument, section: Section): boolean => {
+  const first = section.firstSentence;
+  if (first?.tokens === undefined || section.headingTokens === undefined) return false;
+  const heading = titleTokens(section.heading, measuredHeading(section), section.headingTokens);
+  const announcing = announcerWords(doc.lexicons["heading-announcer"] ?? []).announcing;
+  return namesHeadingSubject(measuredHeading(section), heading, first.text, first.span.start, first.tokens, announcing);
+};
+
+/** 述語の品詞。項目名にあれば、コロンの前は名前ではなく文の頭（The following expenses require receipts:）。 */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX"]);
+
+/**
+ * 行頭の項目名（Current project status: Ongoing）を除いた文。報告の書式が見出しの語で項目を立てるのは書式で、書き手が言ったのは値。
+ * 品詞が読めなければ、項目名かどうか決められないので除かない。
+ */
+const withoutFieldLabel = (sentence: Sentence): string => {
+  const valueStart = fieldValueStart(sentence.text);
+  if (valueStart === undefined || sentence.tokens === undefined) return sentence.text;
+  const labelEnd = sentence.span.start + valueStart;
+  const isClause = sentence.tokens.some((token) => token.span.start < labelEnd && PREDICATE_POS.has(token.pos));
+  return isClause ? sentence.text : sentence.text.slice(valueStart);
+};
+
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
-const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
+const echoedText = (section: Section): string =>
+  section.firstSentence === undefined ? "" : withoutQuotedVariants(withoutFieldLabel(section.firstSentence), measuredHeading(section));
 
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
@@ -117,7 +144,8 @@ export const headingEcho: Detector = (doc, options): Finding[] => {
         !leadsIn(doc, section, leadIns) &&
         !pointsElsewhere(doc, section) &&
         !statesFigure(section.heading, section.firstSentence?.text ?? "") &&
-        !opensForm(section),
+        !opensForm(section) &&
+        !namesSubject(doc, section),
     )
     .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)

package/src/detectors/ime-residue.ts

@@ -6,15 +6,16 @@ import { quoteAround } from "./quote-around.ts";
 /** One stray letter, and where it is in the text. */
 export type StrayLetter = { readonly offset: number; readonly letter: string };
 
-// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after.
-const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[a-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
+// Hiragana or kanji before (after katakana a letter is a label: サイズm, プランb), kana after. Only a consonant: romaji
+// input turns a vowel into kana at once, so a lone vowel is a word of its own (eラーニング, iモード), never a residue.
+const STRAY = /(?<=[\p{Script=Hiragana}\p{Script=Han}々])[b-df-hj-np-tv-z](?=[\p{Script=Hiragana}\p{Script=Katakana}ー])/gu;
 /** Marks that make the run around the letter a path, an address or an assignment (/docs/あaい, a=b). */
 const PATH_MARK = /[/\\=@#]/u;
 
 const runBefore = (text: string, offset: number): string => text.slice(0, offset).split(/\s/u).at(-1) ?? "";
 
 /**
- * One lower-case letter between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
+ * One lower-case consonant between Japanese: hiragana or kanji before, kana after. A letter followed by a particle names
  * something (変数xが, まずxを, をxで), so it is left alone; the particles come from the lexicon.
  */
 export const strayLettersIn = (text: string, particles: readonly string[]): StrayLetter[] =>

package/src/detectors/kanji-compound-slip.ts

@@ -0,0 +1,61 @@
+import type { Detector, Finding, ProseDocument, Token } from "../plugin.ts";
+import { compoundSlipsIn, type CompoundUse, type CompoundWord } from "../kanji-compound-slip.ts";
+
+// Collects the document's kanji runs, from sentences, headings and table cells, each with the words the analyser cut it
+// into, and hands them to compoundSlipsIn.
+
+const KANJI_RUN = /[\p{Script=Han}々]+/gu;
+
+/** The analyser's words over [offset, offset + run), by kanji index. A word without a reading is one the analyser does not know. */
+const wordsOver = (run: string, offset: number, tokens: readonly Token[]): CompoundWord[] | undefined => {
+  const chars = Array.from(run);
+  const starts = chars.map((_, index) => offset + chars.slice(0, index).join("").length);
+  const indexOf = (position: number): number => starts.findIndex((start) => start >= position);
+  const words = tokens
+    .filter((token) => token.span.start < offset + run.length && token.span.end > offset)
+    .map((token) => {
+      const start = Math.max(0, indexOf(token.span.start));
+      const endIndex = indexOf(token.span.end);
+      const crossesRun = token.span.start < offset || token.span.end > offset + run.length;
+      return { start, end: endIndex === -1 ? starts.length : endIndex, known: token.reading !== undefined, crossesRun };
+    });
+  const covered = starts.every((_, index) => words.some((word) => word.start <= index && index < word.end));
+  return covered ? words : undefined;
+};
+
+const usesIn = (text: string, base: number, tokens: readonly Token[]): CompoundUse[] =>
+  [...text.matchAll(KANJI_RUN)].map((match) => {
+    const offset = base + match.index;
+    return { compound: match[0], offset, words: wordsOver(match[0], offset, tokens) };
+  });
+
+const shifted = (tokens: readonly Token[], by: number): Token[] =>
+  tokens.map((token) => ({ ...token, span: { start: token.span.start + by, end: token.span.end + by } }));
+
+const headingUses = (doc: ProseDocument): CompoundUse[] =>
+  doc.sections
+    .filter((section) => section.depth > 0)
+    .flatMap((section) => {
+      // A section's span starts after its heading line; a heading written differently from the source falls back to that line's start.
+      const found = doc.source.lastIndexOf(section.heading, section.span.start);
+      const base = found === -1 ? doc.source.lastIndexOf("\n", section.span.start - 1) + 1 : found;
+      return usesIn(section.heading, base, shifted(section.headingTokens ?? [], base));
+    });
+
+const compoundUsesOf = (doc: ProseDocument): CompoundUse[] => [
+  ...doc.sentences.flatMap((sentence) => usesIn(sentence.text, sentence.span.start, sentence.tokens ?? [])),
+  ...headingUses(doc),
+  ...(doc.tableCells?.() ?? []).flatMap((cell) => usesIn(cell.text, cell.start, cell.tokens ?? [])),
+];
+
+export const kanjiCompoundSlip: Detector = (doc, options): Finding[] => {
+  const ignored = new Set((options.lexicon ?? []).flatMap((entry) => Array.from(entry.pattern)));
+  return compoundSlipsIn(compoundUsesOf(doc), ignored).map((slip) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: slip.written,
+    values: { written: slip.written, usual: slip.usual, count: slip.usualCount, offset: slip.offset },
+  }));
+};

package/src/detectors/kutoten-consistency.ts

@@ -1,4 +1,5 @@
-import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
+import { latinCompanyFormRegExp, latinCompanyFormSpans } from "../latin-company-form.ts";
 import { minorityOf } from "../orthography.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 
@@ -14,7 +15,9 @@ const MARKS = /[、，。．]/gu;
 
 const DIGIT = /[\d０-９]/u;
 
-/** 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。 */
+/**
+ * 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。
+ */
 const LIST_NUMBER = /(?:^|[\s、，,（(])[\d０-９]{1,3}$/u;
 const LIST_NUMBER_REACH = 4;
 
@@ -22,29 +25,96 @@ const LIST_NUMBER_REACH = 4;
 const LATIN_LABEL = /(?:^|[^A-Za-zＡ-Ｚａ-ｚ])[A-Za-zＡ-Ｚａ-ｚ]{1,2}$/u;
 const LATIN_LABEL_REACH = 3;
 
+/** 片仮名の印（イ．ロ．ハ．）。語彙表 item-number の 1 字の片仮名で、前が片仮名でないとき（データ．の タ は語の終わり）。 */
+const KATAKANA = /^[ァ-ヺー]$/u;
+
+/** 句読点として数えない印と名前。kana は片仮名の項目の印、companyForms は英字の会社の形（CO.，LTD.）。 */
+export type MarkExceptions = { readonly kana: ReadonlySet<string>; readonly companyForms: RegExp | undefined };
+
+/**
+ * 印の点の後ろには、同じ行に項目の本文が続く。行の終わりの点（対象はロ．、締切は（予定）10．）は句点。
+ * 文は「イ．」の点で割れることがあるので、文ではなく文書の行の続きを見る。
+ */
+const isFollowed = (source: string, offset: number): boolean => {
+  const lineEnd = source.indexOf("\n", offset);
+  return source.slice(offset + 1, lineEnd === -1 ? source.length : lineEnd).trim() !== "";
+};
+
+type Place = { readonly text: string; readonly at: number; readonly source: string; readonly offset: number };
+
+const isKanaLabel = ({ text, at, source, offset }: Place, kana: ReadonlySet<string>): boolean =>
+  kana.has(text.charAt(at - 1)) && !KATAKANA.test(text.charAt(at - 2)) && isFollowed(source, offset);
+
+/**
+ * 括弧の後ろの番号。注の印の後ろ（(注)２．）か、括弧で閉じた見出しの後ろの最初の番号（事項）１．）。数の後ろに本文が続くときだけ印と読む。
+ * 括弧で添えた語の後ろのほかの数（締切は（予定）10．）は文の終わり。
+ */
+const NOTE_NUMBER_LABEL = /[（(]注[）)][\d０-９]{1,3}$/u;
+const CLOSED_FIRST_NUMBER = /[。）)】］\]][1１]$/u;
+const NOTE_REACH = 6;
+
+const FULLWIDTH_OFFSET = 0xfee0;
+const TRAILING_NUMBER = /[\d０-９]{1,3}$/u;
+const asNumber = (digits: string): number => Number(digits.replace(/[０-９]/gu, (char) => String.fromCharCode(char.charCodeAt(0) - FULLWIDTH_OFFSET)));
+
+const NUMBER_POINT = /(?<![\d０-９])([\d０-９]{1,3})[．.](?![\d０-９])/gu;
+
+/** numbers の中に、1 から順に last まで、この順で並ぶか。 */
+const countsUpTo = (numbers: readonly number[], last: number): boolean => numbers.reduce((next, number) => (number === next ? next + 1 : next), 1) > last;
+
+/**
+ * 行が改行を失って続いた注（…（注）１．…持株会２．株式分割…３．有償…）の番号。同じ行の前に「１．」から一つ前までの番号の点が
+ * 順に並び、後ろに本文が続く。文の中の数の後ろの句点（締切は10．次回は11．）は、前に「１．」からの並びが無い。
+ */
+const isNextInRun = ({ source, offset }: Place): boolean => {
+  const lineStart = source.lastIndexOf("\n", offset) + 1;
+  const before = source.slice(lineStart, offset);
+  const digits = TRAILING_NUMBER.exec(before)?.[0];
+  if (digits === undefined || !isFollowed(source, offset)) return false;
+  const earlier = [...before.slice(0, -digits.length).matchAll(NUMBER_POINT)].map((match) => asNumber(match[1] ?? ""));
+  const previous = asNumber(digits) - 1;
+  return previous > 0 && countsUpTo(earlier, previous);
+};
+
 const isInsideNumber = (text: string, at: number): boolean => DIGIT.test(text.charAt(at - 1)) && DIGIT.test(text.charAt(at + 1));
 
-const isLabelPeriod = (text: string, at: number): boolean =>
-  LIST_NUMBER.test(text.slice(Math.max(0, at - LIST_NUMBER_REACH), at)) || LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at));
+const isLabelPeriod = (place: Place, kana: ReadonlySet<string>): boolean => {
+  const { text, at } = place;
+  const beforeNumber = text.slice(Math.max(0, at - LIST_NUMBER_REACH), at);
+  return (
+    isKanaLabel(place, kana) ||
+    ((NOTE_NUMBER_LABEL.test(text.slice(Math.max(0, at - NOTE_REACH), at)) || CLOSED_FIRST_NUMBER.test(beforeNumber)) &&
+      isFollowed(place.source, place.offset)) ||
+    isNextInRun(place) ||
+    LIST_NUMBER.test(beforeNumber) ||
+    LATIN_LABEL.test(text.slice(Math.max(0, at - LATIN_LABEL_REACH), at))
+  );
+};
 
 /**
- * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認）、
+ * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認、イ．）、
  * 一、二文字の英字の印の後ろの点（Ｑ．、No．）は、日本語の文の区切りではない。
  */
-const isNotPunctuation = (text: string, at: number, mark: string): boolean => {
-  if (mark === "．") return isInsideNumber(text, at) || isLabelPeriod(text, at);
-  if (mark === "，") return isInsideNumber(text, at);
+const isNotPunctuation = (place: Place, mark: string, kana: ReadonlySet<string>): boolean => {
+  if (mark === "．") return isInsideNumber(place.text, place.at) || isLabelPeriod(place, kana);
+  if (mark === "，") return isInsideNumber(place.text, place.at);
   return false;
 };
 
 export type Mark = { readonly kind: Kind["id"]; readonly western: boolean; readonly mark: string; readonly offset: number };
 
-/** 文の中の句読点。鉤括弧で引いたものの中は、引いた元の書き方なので数えない。offset は文書の中の位置。 */
-export const marksIn = (sentence: Sentence): Mark[] => {
-  const quoted: readonly Span[] = quotedSpans(sentence.text);
+/**
+ * 文の中の句読点。鉤括弧で引いたものの中は引いた元の書き方、英字の会社の形（CO.，LTD.）の中は名前の一部なので数えない。
+ * offset は文書の中の位置。
+ */
+export const marksIn = (sentence: Sentence, source: string, exceptions: MarkExceptions): Mark[] => {
+  const skipped: readonly Span[] = [...quotedSpans(sentence.text), ...latinCompanyFormSpans(sentence.text, exceptions.companyForms)];
   return [...sentence.text.matchAll(MARKS)]
-    .filter((match) => !isNotPunctuation(sentence.text, match.index, match[0]))
-    .filter((match) => !isWithinAny(quoted, { start: match.index, end: match.index }))
+    .filter((match) => {
+      const place = { text: sentence.text, at: match.index, source, offset: sentence.span.start + match.index };
+      return !isNotPunctuation(place, match[0], exceptions.kana);
+    })
+    .filter((match) => !isWithinAny(skipped, { start: match.index, end: match.index }))
     .map((match) => {
       const western = match[0] === "，" || match[0] === "．";
       const kind = match[0] === "、" || match[0] === "，" ? "comma" : "period";
@@ -76,14 +146,23 @@ const findingOf = (sentence: Sentence, entry: Mark, kind: Kind, tally: Tally): F
   variant: entry.kind,
 });
 
+const exceptionsOf = (doc: ProseDocument): MarkExceptions => {
+  const patterns = (name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern);
+  return {
+    kana: new Set(patterns("item-number").filter((pattern) => KATAKANA.test(pattern))),
+    companyForms: latinCompanyFormRegExp(patterns("company-form-latin")),
+  };
+};
+
 /**
  * 読点（、と，）と句点（。と．）を、それぞれ文書の中でどちらかにそろえているか。混ざっていれば少ないほうを指摘する。
  * latin-spacing と同じく、同数なら文書が先に使った書き方をその文書の書き方とする。
  */
 export const kutotenConsistency: Detector = (doc, options): Finding[] => {
+  const exceptions = exceptionsOf(doc);
   const located = doc.sentences
     .filter((sentence) => !isCitation(sentence, doc.source))
-    .flatMap((sentence) => marksIn(sentence).map((entry) => ({ sentence, entry })));
+    .flatMap((sentence) => marksIn(sentence, doc.source, exceptions).map((entry) => ({ sentence, entry })));
   return KINDS.flatMap((kind) => {
     const ofKind = located.filter(({ entry }) => entry.kind === kind.id);
     const minority = minorityOf(ofKind.map(({ entry }) => entry.western));

package/src/detectors/lexicon.ts

@@ -16,10 +16,19 @@ const PER = 1000;
 /** 密度を見る rule は短い文書を測らない。単位は言語で違うので床も分ける。 */
 const FLOOR = { word: 200, char: 500 };
 
-type Hit = { readonly sentence: Sentence; readonly matched: string };
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly group?: string | undefined };
 
 const hitsFor = (doc: ProseDocument, lexicon: Lexicon): Hit[] =>
-  doc.sentences.flatMap((sentence) => lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern })));
+  doc.sentences.flatMap((sentence) =>
+    lexicon.filter((entry) => entryIn(sentence, entry)).map((entry) => ({ sentence, matched: entry.pattern, group: entry.group })),
+  );
+
+/**
+ * A lexicon word in group address says how the document speaks to its reader (あなたの). Alone it is the writer's chosen
+ * register, so it counts only beside a phrase from outside the group.
+ */
+const ADDRESS_GROUP = "address";
+const onlyAddress = (hits: readonly Hit[]): boolean => hits.every((hit) => hit.group === ADDRESS_GROUP);
 
 /**
  * 床より短い文書の扱い。skip は測らない。at-floor は SHORT_LENGTH の長さの文書として測り、一つだけなら言わない（一つは礼儀）。
@@ -52,7 +61,7 @@ const densityRule =
     const hits = hitsFor(doc, options.lexicon ?? []);
     const length = wordsOf(doc);
     const isShort = length < FLOOR[doc.lengthUnit];
-    if (hits.length === 0 || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
+    if (onlyAddress(hits) || (isShort && (short === "skip" || hits.length < SHORT_MINIMUM_HITS))) return [];
     if (perThousand(hits.length, isShort ? SHORT_LENGTH[doc.lengthUnit] : length) <= options.limit) return [];
     const density = perThousand(hits.length, length);
     return hits.map((hit) => ({

package/src/detectors/link-shape.ts

@@ -2,7 +2,7 @@ import type { Detector, Finding, Markup, ProseDocument, Span } from "../plugin.t
 import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
 import { linkTextOf } from "../link-text.ts";
 import { bareUrls } from "../bare-url.ts";
-import { isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
+import { isFieldValueUrl, isFileNameAlt, isUrlText, mismatchedHost } from "../link-shape.ts";
 import { minorityWithin } from "../orthography.ts";
 import { readMarkdown, spansOfType } from "../markdown-read.ts";
 
@@ -23,16 +23,23 @@ const FAILED_DESTINATION = "](";
 
 const inside = (span: Span, regions: readonly Span[]): boolean => regions.some((region) => span.start >= region.start && span.start < region.end);
 
+const isFieldValue = (source: string, url: Span): boolean => {
+  const lineStart = source.lastIndexOf("\n", url.start - 1) + 1;
+  const lineEnd = source.indexOf("\n", url.end);
+  return isFieldValueUrl(source.slice(lineStart, url.start), source.slice(url.end, lineEnd === -1 ? source.length : lineEnd));
+};
+
 /**
  * The bare URLs the reader sees as text (outside links, code and quotations). A URL in a table cell is a value the table lists
- * (an example request, a field's content), not a link the prose points to, so tables are left out.
+ * (an example request, a field's content), not a link the prose points to, so tables are left out, and so is a field's value
+ * on its own line (`**Licence text** https://…`).
  */
 const bareUrlSpans = (source: string, markup: Markup): Span[] => {
   const tables = spansOfType(readMarkdown(source).root, "table");
   return markup.texts.flatMap((text) =>
     bareUrls(source.slice(text.start, text.end))
       .map((url) => ({ start: text.start + url.start, end: text.start + url.end }))
-      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables)),
+      .filter((url) => !source.startsWith(FAILED_DESTINATION, url.start - FAILED_DESTINATION.length) && !inside(url, tables) && !isFieldValue(source, url)),
   );
 };