chaffjs 0.34.0 → 0.36.0

package/src/detectors/heading-names.ts

@@ -0,0 +1,31 @@
+import { straightApostrophes } from "../orthography.ts";
+
+const WORD = /[A-Za-z][A-Za-z'-]*/gu;
+const POSSESSIVE = /'s$/u;
+/** 番号が続く語（Example 4、Layer 1）は番号の札で、名前ではない。札の語は流儀によらず大文字で書く。 */
+const NUMBER_FOLLOWS = /^\s+\d/u;
+/** 引用符の中（"Wakayama's Food Ingredients and Food Culture"）は題名や人の言葉で、題の語は名前でなくても大文字になる。 */
+const QUOTE_MARK = /[“”]/gu;
+
+const outsideQuotes = (text: string): string =>
+  text
+    .replace(QUOTE_MARK, '"')
+    .split('"')
+    .filter((_, index) => index % 2 === 0)
+    .join(" ");
+
+const startsUpper = (word: string): boolean => /^[A-Z]/u.test(word);
+
+const midSentenceNames = (sentence: string): string[] =>
+  [...outsideQuotes(straightApostrophes(sentence)).matchAll(WORD)]
+    .slice(1)
+    .filter((match) => startsUpper(match[0]) && !NUMBER_FOLLOWS.test(match.input.slice(match.index + match[0].length)))
+    .map((match) => match[0].replace(POSSESSIVE, ""));
+
+/**
+ * 文書が文の途中で大文字で書く語（NOAA、Flood Inundation Mapping、Alaska）。固有の名前なので、見出しに出ても
+ * どちらの流儀でも大文字のまま。見出しの流儀の証拠に数えないよう、所有格の形（NOAA's）も添えて返す。
+ * 文の頭の語は、名前でなくても大文字になるので数えない。
+ */
+export const namesWrittenMidSentence = (sentences: readonly string[]): ReadonlySet<string> =>
+  new Set(sentences.flatMap(midSentenceNames).flatMap((name) => [name, `${name}'s`]));

package/src/detectors/heading-numbering.ts

@@ -1,6 +1,6 @@
 import type { Detector, Finding, LexiconEntry } from "../plugin.ts";
 import { findingAt, writtenHeadings } from "./markup-finding.ts";
-import { numberingMinorities, numberingStyleOf, UNNUMBERED, type NumberingMinority, type NumberLabel } from "../heading-numbering.ts";
+import { numberingMinorities, numberingStyleOf, opensNumbering, UNNUMBERED, type NumberingMinority, type NumberLabel } from "../heading-numbering.ts";
 
 const labelsOf = (entries: readonly LexiconEntry[]): NumberLabel[] =>
   entries.map((entry) => ({ word: entry.pattern, position: entry.position === "after" ? "after" : "before" }));
@@ -28,7 +28,12 @@ export const headingNumbering: Detector = (doc): Finding[] => {
   const labels = labelsOf(doc.lexicons["heading-number-label"] ?? []);
   const matter = (doc.lexicons["unnumbered-heading"] ?? []).map((entry) => entry.pattern.toLowerCase());
   const styles = headings.map((heading) => numberingStyleOf(heading.text, labels));
-  const read = headings.map((heading, at) => ({ depth: heading.depth, style: styles[at] ?? UNNUMBERED, skipped: isFrontOrBackMatter(heading.text, matter) }));
+  const read = headings.map((heading, at) => ({
+    depth: heading.depth,
+    style: styles[at] ?? UNNUMBERED,
+    skipped: isFrontOrBackMatter(heading.text, matter),
+    opens: opensNumbering(heading.text, labels),
+  }));
   return numberingMinorities(read).flatMap((minority) => {
     const heading = headings[minority.at];
     if (heading === undefined) return [];

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/inch-mark.ts

@@ -0,0 +1,49 @@
+/**
+ * A curly double quote written as the inch mark: a decimal number, then the mark, then a unit (".015 “Hg/hr",
+ * "29.92”Hg"). It quotes nothing, so it opens and closes nothing. text is the section, offset the mark's position.
+ */
+
+/**
+ * A number with a decimal part right before the mark, with at most one space between. A year or a count never has one,
+ * so "In 1969 “Hurricane Camille struck" stays an unclosed quote.
+ */
+const DECIMAL_BEFORE = /\.\p{Nd}+[ \u00A0]?$/u;
+
+/** A short run of letters right after the mark: the unit (Hg, in). */
+const UNIT_AFTER = /^\p{L}{1,3}(?!\p{L})/u;
+
+const LOOK_AROUND = 40;
+const OPENING = "\u201C";
+const CLOSING = "\u201D";
+
+/** Where the paragraph holding offset ends: the next blank line, or the end of the text. */
+const paragraphEnd = (text: string, offset: number): number => {
+  const blank = /\n[ \t\u3000]*\n/u.exec(text.slice(offset));
+  return blank === null ? text.length : offset + blank.index;
+};
+
+const betweenNumberAndUnit = (text: string, offset: number): boolean =>
+  DECIMAL_BEFORE.test(text.slice(Math.max(0, offset - LOOK_AROUND), offset)) && UNIT_AFTER.test(text.slice(offset + 1, offset + 1 + LOOK_AROUND));
+
+/** A closing mark in rest that is not taken by an opening mark written after the start of rest. */
+const closesEarlier = (rest: string): boolean => {
+  const depth = { open: 0, closed: false };
+  [...rest].forEach((mark) => {
+    if (depth.closed) return;
+    if (mark === OPENING) depth.open += 1;
+    else if (mark === CLOSING && depth.open === 0) depth.closed = true;
+    else if (mark === CLOSING) depth.open -= 1;
+  });
+  return depth.closed;
+};
+
+/**
+ * The mark at offset is an inch mark. An opening mark is one only when nothing in its paragraph closes it ("at 2.5
+ * “Hg” quotes something); a closing mark only when no quote is open.
+ */
+export const isInchMark = (text: string, offset: number, quoteOpen: boolean): boolean => {
+  const mark = text.charAt(offset);
+  if ((mark !== OPENING && mark !== CLOSING) || !betweenNumberAndUnit(text, offset)) return false;
+  if (mark === CLOSING) return !quoteOpen;
+  return !closesEarlier(text.slice(offset + 1, paragraphEnd(text, offset)));
+};

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

@@ -1,4 +1,5 @@
 import { joinWords } from "./word-list.ts";
+import { pairMinority } from "./contraction-minority.ts";
 import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
@@ -15,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 の長さの文書として測り、一つだけなら言わない（一つは礼儀）。
@@ -51,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) => ({
@@ -68,7 +78,6 @@ const hedgingDensity = densityRule("excessive-hedging");
 export const cushionDensity = densityRule("cushion-phrase-density", "at-floor");
 /** 語彙表の語の密度だけを見る rule が共通で使う。rule の id は実行側が入れる。 */
 export const phraseDensity = densityRule("");
-export const vagueDensity = densityRule("vague-word-density");
 
 /** 書いたとおりの字。行の折り返しをまたいでいたら空白 1 つに。 */
 const writtenAt = (source: string, span: Span): string => source.slice(span.start, span.end).replace(/\s+/gu, " ").trim();
@@ -258,40 +267,51 @@ export const aiTell: Detector = (doc, options): Finding[] => {
  * **どちらが正しいかは決めない。** 短縮形を使うかどうかは文体の選択で、
  * 立場を取ると方針の違う書き手に rule ごと無視される。spec §12.3。
  *
- * 語彙表は対を持つ（`pattern` と `instead_of`）。片方だけを数えても、
- * 意図した硬い文体なのか不統一なのかが分からない。
+ * 語彙表は対を持つ（`pattern` と `instead_of`）。比べるのは対の中だけで、別の語どうしは比べない。
+ * GOV.UK の文体は「you're」を使い否定は「do not」と書く。語ごとに決めた書きかたで、混在ではない。
+ * 否定と代名詞＋動詞の族にもまとめない。「don't」と「does not」を書き分ける文書もある。
  */
 /**
  * 語の境界で照合する。部分一致だと「it isn't」が「it is」を含んでしまい、
  * 短縮形を使っている文が「使っていない」側に数えられる。
  */
-const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
+const wordUses = (text: string, word: string): number => [...text.matchAll(new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "gu"))].length;
+
+const containsWord = (text: string, word: string): boolean => wordUses(text, word) > 0;
+
+/**
+ * アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。
+ * 折り返した行（「do」で改行して「not」）も、空白 1 つと同じに読む。
+ */
+const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).replace(/\s+/gu, " ").toLowerCase();
+
+type MixedPair = { readonly minority: string; readonly majority: string; readonly count: number };
 
-/** アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。 */
-const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).toLowerCase();
+const mixedPair = (body: string, short: string, long: string): MixedPair | undefined => {
+  const uses = { short: wordUses(body, short), long: wordUses(body, long) };
+  const side = pairMinority(uses);
+  if (side === undefined) return undefined;
+  return side === "short" ? { minority: short, majority: long, count: uses.short } : { minority: long, majority: short, count: uses.long };
+};
 
 export const contractionMix: Detector = (doc, options): Finding[] => {
-  const pairs = (options.lexicon ?? []).flatMap((entry) => (entry.instead_of === undefined ? [] : [{ short: entry.pattern, long: entry.instead_of }]));
-  const body = doc.sentences.map(comparableText).join(" ");
-  const used = pairs.filter((pair) => containsWord(body, pair.short.toLowerCase()));
-  const spelled = pairs.filter((pair) => containsWord(body, pair.long.toLowerCase()));
-  // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
-  if (used.length === 0 || spelled.length === 0) return [];
-  const minorityIsShort = used.length <= spelled.length;
-  const few = minorityIsShort ? used : spelled;
-  if (few.length > options.limit) return [];
-  const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
+  // 文は改行でつなぐ。空白でつなぐと、箇条書きの「What we do」と次の項目「not every…」が「do not」と数えられる。
+  const body = doc.sentences.map(comparableText).join("\n");
+  const mixed = (options.lexicon ?? []).flatMap((entry) => {
+    const pair = entry.instead_of === undefined ? undefined : mixedPair(body, entry.pattern.toLowerCase(), entry.instead_of.toLowerCase());
+    return pair === undefined || pair.count > options.limit ? [] : [pair];
+  });
   const hits = doc.sentences.flatMap((sentence) => {
     const text = comparableText(sentence);
-    const matched = wanted.find((word) => containsWord(text, word));
-    return matched === undefined ? [] : [{ sentence, matched }];
+    const pair = mixed.find((candidate) => containsWord(text, candidate.minority));
+    return pair === undefined ? [] : [{ sentence, pair }];
   });
-  return hits.map((hit) => ({
+  return hits.map(({ sentence, pair }) => ({
     rule: "contraction-consistency",
     severity: "info",
     line: 0,
     column: 0,
-    quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: few.length, limit: options.limit, offset: hit.sentence.span.start },
+    quote: sentence.text.trim(),
+    values: { matched: pair.minority, majority: pair.majority, count: pair.count, limit: options.limit, offset: sentence.span.start },
   }));
 };

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

package/src/detectors/list-item-ending.ts

@@ -0,0 +1,51 @@
+// How a list item's last words are found: past the marks after them (!!, a footnote reference [^1]), which the tagger
+// may call nouns. Pure; reads tokens only.
+import type { Token } from "../plugin.ts";
+
+/** Only marks (!!, ?!, …), whatever tag the tagger gave them. */
+const MARKS_ONLY = /^[\p{P}\s]+$/u;
+
+/** The caret that opens a footnote reference: alone after its masked bracket, or with the bracket when no definition masks it ([^). */
+const CARET = /^\[?\^$/u;
+
+/** The blank a masked bracket leaves before the caret. */
+const BLANK = /^\s+$/u;
+
+/** A footnote label after the caret: [^1], [^note-2]. */
+const FOOTNOTE_LABEL = /^[\p{L}\p{N}_-]+$/u;
+
+/** A token that ends an item's look but is not one of its words. */
+export type IsMark = (token: Token) => boolean;
+
+/** A tag-skipped token, or one made only of marks. */
+export const markOrSkipped =
+  (skipped: ReadonlySet<string>): IsMark =>
+  (token) =>
+    skipped.has(token.pos) || MARKS_ONLY.test(token.surface);
+
+/**
+ * The tokens before a footnote reference at the end (…まだ先 [^1]). The caret must carry its bracket or follow the blank
+ * its masked bracket leaves, so x^2 and "x: ^2" keep their exponent.
+ */
+export const withoutFootnoteReference = (tokens: readonly Token[], isMark: IsMark): readonly Token[] => {
+  const caret = tokens.findLastIndex((token) => CARET.test(token.surface));
+  const opener = tokens[caret];
+  const before = tokens[caret - 1];
+  if (opener === undefined || !(opener.surface.startsWith("[") || (before !== undefined && BLANK.test(before.surface)))) return tokens;
+  const label = tokens.slice(caret + 1);
+  return label.every((token) => isMark(token) || FOOTNOTE_LABEL.test(token.surface)) ? tokens.slice(0, caret) : tokens;
+};
+
+/** The tokens up to the last word: the marks after it dropped. */
+export const withoutTrailingMarks = (tokens: readonly Token[], isMark: IsMark): readonly Token[] =>
+  tokens.slice(0, tokens.findLastIndex((token) => !isMark(token)) + 1);
+
+/**
+ * A noun with あり or なし right after it (翻訳あり, 駐車場なし): a headline's "with" or "without", not a predicate. A
+ * particle between them (翻訳があり) makes it a clause. `endings` holds the words, from the word list headline-ending.
+ */
+export const endsAsHeadline = (words: readonly Token[], endings: ReadonlySet<string>): boolean => {
+  const last = words.at(-1);
+  const before = words.at(-2);
+  return last !== undefined && endings.has(last.surface) && (before?.pos === "NOUN" || before?.pos === "PROPN");
+};