chaffjs 0.16.0 → 0.18.0

package/src/detectors/heading-case.ts

@@ -1,7 +1,33 @@
+import { straightApostrophes } from "../orthography.ts";
+import { withoutCodeWords } from "./heading-code-words.ts";
+
+/** 語の中のアポストロフィは ' に畳んでから読む（Fed’s）。’ を語の外に置くと、’s が小文字の語に見える。 */
 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"]);
+export const MINOR_WORDS: ReadonlySet<string> = new Set([
+  "a",
+  "an",
+  "the",
+  "and",
+  "or",
+  "but",
+  "of",
+  "in",
+  "on",
+  "at",
+  "to",
+  "for",
+  "with",
+  "as",
+  "by",
+  "from",
+  "is",
+  // 語の並び（WORD）は点を含まないので、vs. と v. は vs と v で拾う。
+  "vs",
+  "v",
+  "via",
+]);
 
 /** 大文字だけの語（PR・FCPs）は略語で、どちらの流儀でも大文字のまま。Title Case の証拠にならない。 */
 const ACRONYM = /^[A-Z]{2,}s?$/u;
@@ -10,7 +36,9 @@ const TITLE_DEPTH = 1;
 
 /** 見出しが Title Case か。判定できなければ undefined。 */
 export const isTitleCase = (heading: string): boolean | undefined => {
-  const words = [...heading.matchAll(WORD)].map((match) => match[0]).filter((word) => !MINOR.has(word.toLowerCase()) && !ACRONYM.test(word));
+  const words = [...withoutCodeWords(straightApostrophes(heading)).matchAll(WORD)]
+    .map((match) => match[0])
+    .filter((word) => !MINOR_WORDS.has(word.toLowerCase()) && !ACRONYM.test(word));
   // 1 語の見出しは、どちらの流儀でも先頭が大文字になる。判定できない。
   if (words.length < 2) return undefined;
   const capitalized = words.filter((word) => word[0] === word[0]?.toUpperCase()).length;

package/src/detectors/heading-code-words.ts

@@ -0,0 +1,35 @@
+// A code span closes at the next run of exactly as many backticks as opened it: ``a ` b`` is one span.
+const CODE_SPAN = /(?<!`)(`+)(?!`)[\s\S]*?(?<!`)\1(?!`)/gu;
+
+const OPENING = new Set([..."(\"'“‘["]);
+const CLOSING = new Set([...")\"'”’].,:;!?"]);
+
+/** The word without the punctuation around it: `(optional)` is `optional`, `Setup:` is `Setup`. */
+const bareWord = (token: string): string => {
+  const chars = [...token];
+  const first = chars.findIndex((char) => !OPENING.has(char));
+  const last = chars.findLastIndex((char) => !CLOSING.has(char));
+  return first === -1 || last < first ? "" : chars.slice(first, last + 1).join("");
+};
+
+/** A mark a word of prose does not carry inside it: `config.yaml`, `snake_case`, `src/index`, `useEffect()`, `$HOME`. */
+const CODE_MARK = /[._/\\=(){}[\]<>$@#*]/u;
+
+/** A word that starts in lower case and has a capital after it (`useEffect`, `iPhone`): its case is its owner's. */
+const CAMEL_CASE = /^[a-z]+[A-Z]/u;
+
+const isCodeWord = (token: string): boolean => {
+  const bare = bareWord(token);
+  return bare.startsWith("-") || CAMEL_CASE.test(bare) || CODE_MARK.test(bare);
+};
+
+/**
+ * The heading without its code words: a code span, a flag (`--force`), a file name (`config.yaml`), an identifier
+ * (`useEffect`). They are written the same in Title Case and in sentence case, so they are evidence for neither.
+ */
+export const withoutCodeWords = (heading: string): string =>
+  heading
+    .replace(CODE_SPAN, " ")
+    .split(/\s+/u)
+    .filter((token) => !isCodeWord(token))
+    .join(" ");

package/src/detectors/heading-echo.ts

@@ -1,4 +1,7 @@
-import { lengthOf } from "../measure.ts";
+import { lengthOf, proseText } from "../measure.ts";
+import { newContentMorphemes } from "./content-morphemes.ts";
+import { echoedHeadingUnits, trigrams } from "./heading-overlap.ts";
+import { titleTokens } from "../heading-label.ts";
 import { handsOver } from "./lead-in.ts";
 import { withoutQuotedVariants } from "./quoted-variant.ts";
 import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../plugin.ts";
@@ -6,17 +9,6 @@ import type { Detector, Finding, LengthUnit, ProseDocument, Section } from "../p
 /** 見出しが短すぎると、偶然の一致で 100% になる。これ未満の見出しは見ない。 */
 const MIN_GRAMS = 4;
 
-/**
- * 文字 3-gram で測る。
- * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
- */
-const trigrams = (text: string): Set<string> => {
-  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
-  // 同じ語でも一致しなくなる（Generating Output → generated output）。
-  const clean = [...text.toLowerCase().replace(/\s+/gu, "")];
-  return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => clean.slice(index, index + 3).join("")));
-};
-
 /**
  * Jaccard ではなく包含率を使う。
  *
@@ -39,18 +31,22 @@ const containment = (heading: Set<string>, sentence: Set<string>): number => {
  */
 const NEW_MATERIAL = { word: 6, char: 20 };
 
-const headingUnits = (heading: string, unit: LengthUnit): number =>
-  unit === "word"
-    ? heading
-        .trim()
-        .split(/\s+/u)
-        .filter((word) => word.length > 0).length
-    : heading.replace(/\s+/gu, "").length;
+/**
+ * 空白で語を分けない言語は、品詞が読めれば文字ではなく見出しに無い内容語で測る。文字数は中身の量を言わない:
+ * 「会社に勤めています」は 9 文字で 会社・勤める を足し、「について説明します」は同じ 9 文字で 説明 しか足さない。
+ * 内容語 2 つで足りる（こころさんのお父さんは、会社に勤めています。）。日本語の corpus で測った（yarn corpus）。
+ */
+const NEW_CONTENT_MORPHEMES = 1;
+
+/** 重なりを測る見出し。頭の番号の札（例 3：、Step 3:、1.）は本文で繰り返されないので、数えると短い見出しほど重なりが下がる。 */
+const measuredHeading = (section: Section): string => section.unlabeledHeading ?? section.heading;
 
 const addsLittle = (section: Section, unit: LengthUnit): boolean => {
   const first = section.firstSentence;
   if (first === undefined) return false;
-  return lengthOf(first, unit) - headingUnits(section.heading, unit) <= NEW_MATERIAL[unit];
+  if (unit === "char" && first.tokens !== undefined && section.headingTokens !== undefined)
+    return newContentMorphemes(titleTokens(section.heading, measuredHeading(section), section.headingTokens), first.tokens) <= NEW_CONTENT_MORPHEMES;
+  return lengthOf(first, unit) - echoedHeadingUnits(measuredHeading(section), proseText(first), unit) <= NEW_MATERIAL[unit];
 };
 
 /** 最初の文が、同じ節の後ろ（箇条書き・表・コード）へ読者を渡している。 */
@@ -60,14 +56,14 @@ const leadsIn = (doc: ProseDocument, section: Section, phrases: readonly string[
 };
 
 /** 見出しとの重なりを測る文。用語集や表記の手引きは見出しの語の別の書き方を引用する（Not “datacentre”）ので、それは数えない。 */
-const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", section.heading);
+const echoedText = (section: Section): string => withoutQuotedVariants(section.firstSentence?.text ?? "", measuredHeading(section));
 
 export const headingEcho: Detector = (doc, options): Finding[] => {
   const leadIns = (doc.lexicons["lead-in"] ?? []).map((entry) => entry.pattern);
   return doc.sections
     .filter((section) => section.heading.length > 0 && section.firstSentence !== undefined && addsLittle(section, doc.lengthUnit))
     .filter((section) => !leadsIn(doc, section, leadIns))
-    .map((section) => ({ section, overlap: Math.round(containment(trigrams(section.heading), trigrams(echoedText(section))) * 100) }))
+    .map((section) => ({ section, overlap: Math.round(containment(trigrams(measuredHeading(section)), trigrams(echoedText(section))) * 100) }))
     .filter(({ overlap }) => overlap >= options.limit)
     .map(({ section, overlap }) => ({
       rule: "heading-echo",

package/src/detectors/heading-level-skip.ts

@@ -0,0 +1,19 @@
+import type { Detector, Finding, MarkupHeading } from "../plugin.ts";
+import { findingAt, markupOf } from "./markup-finding.ts";
+
+export type SkippedHeading = { readonly heading: MarkupHeading; readonly from: number };
+
+/**
+ * 一つ前の見出しより二段以上深い見出し（## の次の ####）。最初の見出しは何段から始めてもよい。
+ * 飛んだ後は、飛んだ先の深さを基準にする（#### の次の #### は飛んでいない）。markdownlint の MD001 と同じ数え方。
+ */
+export const skippedHeadings = (headings: readonly MarkupHeading[]): SkippedHeading[] =>
+  headings.flatMap((heading, index) => {
+    const previous = headings[index - 1];
+    return previous !== undefined && heading.depth > previous.depth + 1 ? [{ heading, from: previous.depth }] : [];
+  });
+
+export const headingLevelSkip: Detector = (doc): Finding[] =>
+  skippedHeadings(markupOf(doc)?.headings ?? []).map(({ heading, from }) =>
+    findingAt(doc, heading, { heading: heading.text, from, to: heading.depth, expected: from + 1 }),
+  );

package/src/detectors/heading-overlap.ts

@@ -0,0 +1,65 @@
+// How much of a section's heading its first sentence takes up: the heading's character trigrams, and the part of the
+// heading the sentence repeats, in the document's length unit. Pure; heading-echo decides with these.
+import type { LengthUnit } from "../plugin.ts";
+
+const foldedChars = (text: string): string[] => [...text.toLowerCase().replace(/\s+/gu, "")];
+
+const trigramAt = (chars: readonly string[], index: number): string => chars.slice(index, index + 3).join("");
+
+/**
+ * 文字 3-gram で測る。
+ * 語 n-gram にすると wordSplit capability が要り、L1（言語を問わず動く）から外れる。
+ */
+export const trigrams = (text: string): Set<string> => {
+  // 大文字小文字を畳む。英語では見出しが Title Case、本文が小文字になり、
+  // 同じ語でも一致しなくなる（Generating Output → generated output）。
+  const clean = foldedChars(text);
+  return new Set(clean.slice(0, Math.max(0, clean.length - 2)).map((__char, index) => trigramAt(clean, index)));
+};
+
+/** A word as compared across heading and sentence: case folded, the punctuation around it dropped ("Spacewalks?" is spacewalks). */
+const foldedWord = (word: string): string => {
+  const chars = [...word.toLowerCase()];
+  const isWordChar = (char: string): boolean => /[\p{L}\p{N}]/u.test(char);
+  return chars.slice(chars.findIndex(isWordChar), chars.findLastIndex(isWordChar) + 1).join("");
+};
+
+const headingWords = (heading: string): string[] =>
+  heading
+    .trim()
+    .split(/\s+/u)
+    .filter((word) => word.length > 0);
+
+/** Below this length a word repeats another only as itself: "on" is not repeated by "one", nor "go" by "going". */
+const MIN_STEM = 4;
+
+/** The same word, or one of them the other with an ending added (level → levels, reference → references). */
+const isSameWord = (headingWord: string, sentenceWord: string): boolean => {
+  if (headingWord === sentenceWord) return true;
+  const [shorter, longer] = headingWord.length < sentenceWord.length ? [headingWord, sentenceWord] : [sentenceWord, headingWord];
+  return shorter.length >= MIN_STEM && longer.startsWith(shorter);
+};
+
+/** The heading's words that the sentence repeats; a word of punctuation alone is never repeated. */
+const echoedWords = (heading: string, sentence: string): number => {
+  const said = sentence.split(/\s+/u).map(foldedWord);
+  return headingWords(heading)
+    .map(foldedWord)
+    .filter((word) => word !== "" && said.some((other) => isSameWord(word, other))).length;
+};
+
+/** The heading's characters (spaces aside) that a trigram the sentence also has covers. */
+const echoedChars = (heading: string, sentence: string): number => {
+  const said = trigrams(sentence);
+  const clean = foldedChars(heading);
+  const covered = new Set(clean.flatMap((__char, index) => (said.has(trigramAt(clean, index)) ? [index, index + 1, index + 2] : [])));
+  return covered.size;
+};
+
+/**
+ * How much of the heading the sentence repeats, in the document's length unit. A sentence that repeats only part of it
+ * ("How Do Astronauts Go on Spacewalks?" → "When astronauts go on spacewalks, they wear spacesuits…") keeps the rest of
+ * its length as its own material.
+ */
+export const echoedHeadingUnits = (heading: string, sentence: string, unit: LengthUnit): number =>
+  unit === "word" ? echoedWords(heading, sentence) : echoedChars(heading, sentence);

package/src/detectors/image-alt-text.ts

@@ -0,0 +1,11 @@
+import type { Detector, Finding, MarkupImage } from "../plugin.ts";
+import { findingAt, markupOf, quoteOf } from "./markup-finding.ts";
+
+/** 代替テキストの無い画像。Markdown の `![](a.png)` は alt が空、HTML の `<img>` は alt 属性が無いもの。`alt=""` は飾りと明示したので数えない。 */
+const lacksAlt = (source: string, image: MarkupImage): boolean => {
+  if (image.alt === undefined) return true;
+  return image.alt.trim() === "" && !source.startsWith("<", image.start);
+};
+
+export const imageAltText: Detector = (doc): Finding[] =>
+  (markupOf(doc)?.images ?? []).filter((image) => lacksAlt(doc.source, image)).map((image) => findingAt(doc, image, { image: quoteOf(doc.source, image) }));

package/src/detectors/index.ts

@@ -7,16 +7,40 @@ import { sentenceRhythm } from "./sentence-rhythm.ts";
 import { phraseCount, phraseMatch } from "./phrase-match.ts";
 import { agentlessPassive } from "./agentless-passive.ts";
 import { doubledWord } from "./doubled-word.ts";
+import { agreementSlip } from "./agreement-slip.ts";
 import { sentenceEnding } from "./sentence-ending.ts";
 import { doubledParticle, nounEnding } from "./token-shape.ts";
 import { kanjiRun, middleDot } from "./char-shape.ts";
-import { adverbDensity, conjunctionRun, expletive, oxfordComma, titleCaseMix } from "./en-shape.ts";
+import { adverbDensity, conjunctionRun, expletive, titleCaseMix } from "./en-shape.ts";
+import { oxfordComma } from "./oxford-comma.ts";
 import { paragraphLength, paragraphVariance, preambleLength, ruleOfThree, sectionUniformity } from "./structure.ts";
 import { concreteEvidence, dashDensity, emojiDensity, ngramRepetition, undefinedAcronym } from "./signals.ts";
 import { aiTell, contractionMix, cushionDensity, hedging, repeatedConjunction, unqualifiedSuperlative } from "./lexicon.ts";
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 import { latinSpacing, preferredTerm } from "./orthography.ts";
-import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.ts";
+import { straySpace } from "./stray-space.ts";
+import { announcedCount } from "./announced-count.ts";
+import { danglingFigure } from "./dangling-figure.ts";
+import {
+  danglingReference,
+  dateOrder,
+  dateRangeReversed,
+  dateWeekdayMismatch,
+  duplicateDefinition,
+  numberingGap,
+  percentSumMismatch,
+  totalMismatch,
+} from "./structure-tree.ts";
+import { headingLevelSkip } from "./heading-level-skip.ts";
+import { imageAltText } from "./image-alt-text.ts";
+import { brokenLink } from "./broken-link.ts";
+import { urlRunOn } from "./url-run-on.ts";
+import { unbalancedBracket } from "./unbalanced-bracket.ts";
+import { doubledPunctuation } from "./doubled-punctuation.ts";
+import { kutotenConsistency } from "./kutoten-consistency.ts";
+import { katakanaLongVowel } from "./long-vowel.ts";
+import { customPattern, customTokens, customWords } from "./custom.ts";
+import { assistantResidue, colonLeadIn, contrastFraming, openerDensity, openerPile, unfilledPlaceholder } from "./ai-phrasing.ts";
 
 /** rule 定義の how_to_find がここを引く。rule 側は実装を知らない。 */
 export const DETECTORS: Readonly<Record<string, Detector>> = {
@@ -32,6 +56,7 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "noun-ending": nounEnding,
   "doubled-particle": doubledParticle,
   "doubled-word": doubledWord,
+  "agreement-slip": agreementSlip,
   "kanji-run": kanjiRun,
   "middle-dot": middleDot,
   "adverb-density": adverbDensity,
@@ -54,16 +79,38 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "unqualified-superlative": unqualifiedSuperlative,
   "repeated-conjunction": repeatedConjunction,
   "ai-tell": aiTell,
+  "contrast-framing": contrastFraming,
+  "stock-transition": openerDensity,
+  "opener-pile": openerPile,
+  "colon-lead-in": colonLeadIn,
+  "assistant-residue": assistantResidue,
+  "unfilled-placeholder": unfilledPlaceholder,
   "contraction-mix": contractionMix,
   "internal-jargon": internalJargon,
   "required-sections": requiredSections,
   "proper-noun-density": properNounDensity,
   "preferred-term": preferredTerm,
   "latin-spacing": latinSpacing,
+  "stray-space": straySpace,
+  "katakana-long-vowel": katakanaLongVowel,
+  "custom-words": customWords,
+  "custom-pattern": customPattern,
+  "custom-tokens": customTokens,
   "dangling-reference": danglingReference,
   "date-weekday-mismatch": dateWeekdayMismatch,
   "date-order": dateOrder,
   "total-mismatch": totalMismatch,
   "numbering-gap": numberingGap,
   "duplicate-definition": duplicateDefinition,
+  "announced-count": announcedCount,
+  "dangling-figure": danglingFigure,
+  "date-range-reversed": dateRangeReversed,
+  "percent-sum-mismatch": percentSumMismatch,
+  "heading-level-skip": headingLevelSkip,
+  "image-alt-text": imageAltText,
+  "broken-link": brokenLink,
+  "url-run-on": urlRunOn,
+  "unbalanced-bracket": unbalancedBracket,
+  "doubled-punctuation": doubledPunctuation,
+  "kutoten-consistency": kutotenConsistency,
 };

package/src/detectors/kutoten-consistency.ts

@@ -0,0 +1,96 @@
+import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import { minorityStyle } from "../orthography.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** 日本語の読点と句点の、二つの書き方。「、。」と、横書きの論文や公用文に多い「，．」。どちらが正しいかは決めない。 */
+type Kind = { readonly id: "comma" | "period"; readonly usual: string; readonly western: string };
+
+const KINDS: readonly Kind[] = [
+  { id: "comma", usual: "、", western: "，" },
+  { id: "period", usual: "。", western: "．" },
+];
+
+const MARKS = /[、，。．]/gu;
+
+const DIGIT = /[\d０-９]/u;
+
+/** 番号の印（行の頭や読点・空白・括弧の後ろの「１．」「２．」）。文の中の数の後ろの点（締切は10．）は文の終わり。 */
+const LIST_NUMBER = /(?:^|[\s、，,（(])[\d０-９]{1,3}$/u;
+const LIST_NUMBER_REACH = 4;
+
+/** 一、二文字の英字だけの印（Ｑ．、No．）。「API．」のような語の後ろの点は文の終わり。 */
+const LATIN_LABEL = /(?:^|[^A-Za-zＡ-Ｚａ-ｚ])[A-Za-zＡ-Ｚａ-ｚ]{1,2}$/u;
+const LATIN_LABEL_REACH = 3;
+
+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));
+
+/**
+ * 句読点として数えない「，」「．」。数の中の桁の区切りと小数点（１，０００、３．５）、番号の印の点（１．はじめに、、２．確認）、
+ * 一、二文字の英字の印の後ろの点（Ｑ．、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);
+  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);
+  return [...sentence.text.matchAll(MARKS)]
+    .filter((match) => !isNotPunctuation(sentence.text, match.index, match[0]))
+    .filter((match) => !isWithinAny(quoted, { start: match.index, end: match.index }))
+    .map((match) => {
+      const western = match[0] === "，" || match[0] === "．";
+      const kind = match[0] === "、" || match[0] === "，" ? "comma" : "period";
+      return { kind, western, mark: match[0], offset: sentence.span.start + match.index };
+    });
+};
+
+/**
+ * 注や文献の番号と空白で始まる行（白書の「2 亀田健司，「…」，2018年」、「[1] 山田太郎，…」「注1 …」「※1 …」）。
+ * 白書や論文の注と文献は、本文と違う区切り方で書く決まりがある。
+ */
+const NOTE_NUMBER = /^(?:[\d０-９]{1,3}|[[［][\d０-９]{1,3}[\]］]|注[\d０-９]{1,3}|※[\d０-９]{0,3})[\u3000 ]/u;
+
+const URL_SCHEME = /https?:\/\//u;
+
+/** 文献や出典を挙げた文。注の番号で始まるか、URL を含む。区切りは引いた元や文献の書き方に従う。 */
+export const isCitation = (sentence: Sentence, source: string): boolean =>
+  NOTE_NUMBER.test(sentence.text.trimStart()) || URL_SCHEME.test(source.slice(sentence.span.start, sentence.span.end));
+
+type Tally = { readonly count: number; readonly of: number; readonly limit: number };
+
+const findingOf = (sentence: Sentence, entry: Mark, kind: Kind, tally: Tally): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: sentence.text.trim(),
+  values: { mark: entry.mark, usual: entry.western ? kind.usual : kind.western, ...tally, offset: entry.offset },
+  variant: entry.kind,
+});
+
+/**
+ * 読点（、と，）と句点（。と．）を、それぞれ文書の中でどちらかにそろえているか。混ざっていれば少ないほうを指摘する。
+ * latin-spacing と同じく、同数なら文書が先に使った書き方をその文書の書き方とする。
+ */
+export const kutotenConsistency: Detector = (doc, options): Finding[] => {
+  const located = doc.sentences
+    .filter((sentence) => !isCitation(sentence, doc.source))
+    .flatMap((sentence) => marksIn(sentence).map((entry) => ({ sentence, entry })));
+  return KINDS.flatMap((kind) => {
+    const ofKind = located.filter(({ entry }) => entry.kind === kind.id);
+    const minority = minorityStyle(ofKind.map(({ entry }) => ({ spaced: entry.western })));
+    if (minority === undefined) return [];
+    const odd = ofKind.filter(({ entry }) => entry.western === minority);
+    if (odd.length < options.limit) return [];
+    const tally = { count: odd.length, of: ofKind.length, limit: options.limit };
+    return odd.map(({ sentence, entry }) => findingOf(sentence, entry, kind, tally));
+  });
+};

package/src/detectors/lead-in.ts

@@ -1,13 +1,15 @@
 /** 文末のコロン。後ろに強調の印（**・_）や空白が残っていても見る。 */
 const ENDS_WITH_COLON = /[:：][\s*_]*$/u;
 
+export const endsWithColon = (sentence: string): boolean => ENDS_WITH_COLON.test(sentence.trim());
+
 /**
  * 後ろの箇条書きや表へ読者を渡す文（「次のとおりとする。」「The following expenses require receipts:」）。
  * 見出しの語を繰り返していても、中身は後ろにある。言い回しは言語パッケージの語彙表 lead-in が持つ。
  */
 export const isLeadIn = (sentence: string, phrases: readonly string[]): boolean => {
   const text = sentence.trim().toLowerCase();
-  return ENDS_WITH_COLON.test(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
+  return endsWithColon(text) || phrases.some((phrase) => phrase !== "" && text.includes(phrase.toLowerCase()));
 };
 
 /** 渡す先（following: 同じ節の、その文より後ろ）が空なら、渡す文ではなくただの繰り返し。 */

package/src/detectors/letter-joined-name.ts

@@ -0,0 +1,15 @@
+/**
+ * 一文字を - で語の前に繋いだ名前（J-STAGE、X-RAY、T-Mobile、e-Gov）。前の一文字が新しい名前を作るので、中の大文字の語は
+ * 略語ではない（J-STAGE は STAGE の説明を待たない）。後ろに一文字を繋いだ語（ITU-T、GOODS-S）は略語の一種で、略語は
+ * 説明を待つまま。部品が二つとも二文字以上（RT-PCR）なら繋いだ略語のまま。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 語を空白で区切る文字（é、α、分けて書いた e と ́）や数字が接していれば長い語の一部。仮名や漢字は接していてよい（論文はJ-STAGEで）。
+const SPACED_WORD_CHAR = String.raw`\p{Script=Latin}\p{Script=Greek}\p{Script=Cyrillic}\p{M}\p{N}_&`;
+const LETTER_JOINED_NAME = new RegExp(String.raw`(?<![${SPACED_WORD_CHAR}.-])[A-Za-z]-[A-Za-z]{2,}(?![${SPACED_WORD_CHAR}-]|\.[A-Za-z0-9])`, "gu");
+
+/** 文の中の、一文字を - で語の前に繋いだ名前の範囲。 */
+export const letterJoinedNameSpans = (text: string): Span[] =>
+  [...text.matchAll(LETTER_JOINED_NAME)].map((match) => ({ start: match.index, end: match.index + match[0].length }));

package/src/detectors/lexicon-match.ts

@@ -1,5 +1,6 @@
 import type { LexiconEntry, Sentence, Token } from "../plugin.ts";
 import { proseText } from "../measure.ts";
+import { straightApostrophes } from "../orthography.ts";
 
 /** 活用する品詞。"best" を "good" と同じ語にはしない。 */
 const INFLECTING = new Set(["VERB", "AUX"]);
@@ -15,6 +16,12 @@ const sameWord = (written: Token, entry: Token): boolean => {
   return inflects && entry.lemma?.toLowerCase() === surface && written.lemma?.toLowerCase() === surface;
 };
 
+/** 品詞が無いときに照らす形。大文字小文字と、アポストロフィの形（it’s と it's）は語を変えない。 */
+export const comparableWords = (text: string): string => straightApostrophes(text).toLowerCase();
+
+/** 文を、品詞が無いときに照らす形に。行の折り返しの空白はまとめる。 */
+export const comparableText = (sentence: Sentence): string => comparableWords(proseText(sentence));
+
 const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number): boolean =>
   entry.every((word, offset) => {
     const written = tokens[start + offset];
@@ -28,7 +35,7 @@ const runsAt = (tokens: readonly Token[], entry: readonly Token[], start: number
 export const entryIn = (sentence: Sentence, entry: LexiconEntry): boolean => {
   const tokens = sentence.tokens;
   const words = entry.tokens;
-  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().includes(entry.pattern.toLowerCase());
+  if (tokens === undefined || words === undefined || words.length === 0) return comparableText(sentence).includes(comparableWords(entry.pattern));
   return tokens.some((_token, start) => runsAt(tokens, words, start));
 };
 
@@ -48,7 +55,7 @@ const LEADING_MARK = new Set(["PUNCT", "SYM"]);
 export const entryOpens = (sentence: Sentence, entry: LexiconEntry): boolean => {
   const tokens = sentence.tokens;
   const words = entry.tokens;
-  if (tokens === undefined || words === undefined || words.length === 0) return proseText(sentence).toLowerCase().startsWith(entry.pattern.toLowerCase());
+  if (tokens === undefined || words === undefined || words.length === 0) return comparableText(sentence).startsWith(comparableWords(entry.pattern));
   const first = tokens.findIndex((token) => !LEADING_MARK.has(token.pos));
   return runsAt(tokens, words, first);
 };

package/src/detectors/lexicon.ts

@@ -1,4 +1,5 @@
 import { joinWords } from "./word-list.ts";
+import { straightApostrophes } from "../orthography.ts";
 import { wordsOf } from "./structure.ts";
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { entryIn, entryOpens, entryRanges, type TokenRange } from "./lexicon-match.ts";
@@ -227,9 +228,12 @@ export const aiTell: Detector = (doc, options): Finding[] => {
  */
 const containsWord = (text: string, word: string): boolean => new RegExp(`\\b${word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&")}\\b`, "u").test(text);
 
+/** アポストロフィの形（don’t と don't）は短縮形かどうかを変えない。違うのは印刷の形で、文体ではない。 */
+const comparableText = (sentence: Sentence): string => straightApostrophes(sentence.text).toLowerCase();
+
 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((sentence) => sentence.text.toLowerCase()).join(" ");
+  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()));
   // 片方しか無ければ一貫している。両方あるときだけ、少数派を指摘する。
@@ -239,7 +243,7 @@ export const contractionMix: Detector = (doc, options): Finding[] => {
   if (few.length > options.limit) return [];
   const wanted = few.map((pair) => (minorityIsShort ? pair.short : pair.long).toLowerCase());
   const hits = doc.sentences.flatMap((sentence) => {
-    const text = sentence.text.toLowerCase();
+    const text = comparableText(sentence);
     const matched = wanted.find((word) => containsWord(text, word));
     return matched === undefined ? [] : [{ sentence, matched }];
   });