chaffjs 0.17.0 → 0.18.0

package/src/detectors/doubled-punctuation.ts

@@ -0,0 +1,49 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { quoteAround } from "./quote-around.ts";
+
+/**
+ * 句読点が二つ並んだところ（「。。」「、。」「,,」「..」）。打ち直しで残った印。
+ * 同じ印を三つ以上並べたもの（「...」「。。。」）は、わざと伸ばした書き方なので数えない。
+ * コロンは「::」（C++ の名前、IPv6）があるので見ない。
+ */
+const PUNCTUATION_RUN = /[、。，．,.;；]{2,}/gu;
+
+/** 略語の点の後ろの読点やセミコロン（e.g.,、Inc.,、etc.;）。 */
+const AFTER_ABBREVIATION = /^\.[,;]$/u;
+
+const WORD = /[\p{L}\p{N}]/u;
+
+/** 「..」の前後が字か数字か「/」なら、範囲や道のり（1..10、a..b、../）で、書き損じではない。 */
+const JOINED = /[\p{L}\p{N}/]/u;
+
+const isDrawnOut = (run: string): boolean => run.length >= 3 && [...run].every((mark) => mark === run.charAt(0));
+
+const isJoinedDots = (text: string, start: number, run: string): boolean =>
+  run === ".." && (JOINED.test(text.charAt(start + run.length)) || text.charAt(start - 1) === "/");
+
+export type DoubledMarks = { readonly start: number; readonly run: string };
+
+/** 並びの終わりの点が次の語の頭（「、.NET」「。.well-known」）なら、その点は語のうち。 */
+const withoutWordDot = (text: string, found: DoubledMarks): DoubledMarks =>
+  found.run.endsWith(".") && !isDrawnOut(found.run) && found.run !== ".." && WORD.test(text.charAt(found.start + found.run.length))
+    ? { start: found.start, run: found.run.slice(0, -1) }
+    : found;
+
+const isSlip = (text: string, { start, run }: DoubledMarks): boolean =>
+  run.length >= 2 && !isDrawnOut(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
+
+/** text の中の、句読点が重なった並び（位置と並び）。 */
+export const doubledMarks = (text: string): DoubledMarks[] =>
+  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found));
+
+export const doubledPunctuation: Detector = (doc): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  return doubledMarks(text).map(({ start, run }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, start, start + run.length),
+    values: { marks: run, offset: start },
+  }));
+};

package/src/detectors/doubled-word.ts

@@ -90,7 +90,18 @@ export const doubledAt = (source: string, first: Token, second: Token, spaced: b
 export const isNameBefore = (first: Token, second: Token, opensSentence: boolean): boolean =>
   !opensSentence && !isDeterminer(first) && UPPER_START.test(first.surface) && LOWER_START.test(second.surface);
 
-const opensSentence = (tokens: readonly Token[], at: number): boolean => !tokens.slice(0, at).some((token) => LETTER.test(token.surface));
+/** 大文字 1 字の語。 */
+const SINGLE_CAPITAL = /^\p{Lu}$/u;
+
+/**
+ * 文の途中の大文字 1 字の冠詞（at site A the connection、Peer A our copy）は、名前にした文字。冠詞は文の途中で大文字にならない。
+ * 同じ語（site A a）と文頭の A the は書き損じのまま。
+ */
+export const isLetterName = (first: Token, second: Token, opensSentence: boolean): boolean =>
+  !opensSentence && SINGLE_CAPITAL.test(first.surface) && !sameWord(first, second);
+
+/** 文の最初の、字のある語の位置。at 語目より前に字のある語が無ければ、at 語目は文の書き出し。 */
+const firstWordIndex = (tokens: readonly Token[]): number => tokens.findIndex((token) => LETTER.test(token.surface));
 
 const repeatsPrevious = (tokens: readonly Token[], at: number): boolean => {
   const [previous, token] = [tokens[at - 1], tokens[at]];
@@ -110,14 +121,18 @@ export const opensPhrase = (tokens: readonly Token[], at: number, phrases: Lexic
     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) => {
+export const doubledIn = (source: string, tokens: readonly Token[], spaced: boolean, allowed: Lexicon, phrases: Lexicon = []): Doubled[] => {
+  const firstWord = firstWordIndex(tokens);
+  return 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 }];
+    // first は字のある語なので、firstWord は見つかっていて index - 1 以下。
+    const opens = firstWord >= index - 1;
+    return isNameBefore(first, second, opens) || isLetterName(first, second, opens) ? [] : [{ first, second }];
   });
+};
 
 /** 印を挟んでいても（the [the）、見せるのは二語だけ。 */
 const wordOf = (doubled: Doubled, spaced: boolean): string => [doubled.first.surface, doubled.second.surface].join(spaced ? " " : "");

package/src/detectors/enumerated-runs.ts

@@ -12,10 +12,19 @@ const labelOf = (node: StructureNode): string => {
  * 条の外で、番号の付いた行（言語パッケージが項目と読んだ「（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")),
-];
+export const numberedStarts = (root: StructureNode, inArticle = false): NumberedStart[] => {
+  const found: NumberedStart[] = [];
+  const pending = [{ node: root, inArticle }];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (next === undefined) break;
+    const { node } = next;
+    if (node.kind === "item" && !next.inArticle) found.push({ start: node.span.start, label: labelOf(node) });
+    const within = next.inArticle || node.kind === "article";
+    node.children.toReversed().forEach((child) => pending.push({ node: child, inArticle: within }));
+  }
+  return found;
+};
 
 const INDENT = /^[ \t\u3000]*/u;
 

package/src/detectors/gram-furniture.ts

@@ -0,0 +1,30 @@
+import type { Span } from "../plugin.ts";
+
+// ひな形が項目ごとに繰り返す飾り（一覧の札、リンクの文字、記号の並び）。書き手の言い回しではない。
+
+const MARK = /[\p{P}\p{S}]/gu;
+
+const BRACKETED = /[([{（［｛]([^()[\]{}（）［］｛｝]*)[)\]}）］｝]/gu;
+
+/** 札の 1 項目。空白を含まない 1 語で、平仮名も含まない（日本語で平仮名を含めば、括弧の中は言い回し）。 */
+const TAG_ITEM = /^\s*[^\s\p{Script=Hiragana}]+\s*$/u;
+
+/** 括弧の中が、1 語か 1 語ずつの並び（(replaced)、[pdf, html, other]）。(if applicable) のような句は札ではない。 */
+const isTag = (inside: string): boolean => inside.split(/[,、]/u).every((item) => TAG_ITEM.test(item));
+
+const spansOf = (text: string, pattern: RegExp, keep: (match: RegExpExecArray) => boolean): Span[] =>
+  [...text.matchAll(pattern)].filter(keep).map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** text の各位置（UTF-16 の単位）が飾りか。記号・句読点、括弧でくくった札、リンクの文字（linked が決める）。 */
+export const furnitureMask = (text: string, linked: (index: number) => boolean): boolean[] => {
+  const mask = Array.from({ length: text.length }, (_, index) => linked(index));
+  [...spansOf(text, MARK, () => true), ...spansOf(text, BRACKETED, (match) => isTag(match[1] ?? ""))].forEach((span) => mask.fill(true, span.start, span.end));
+  return mask;
+};
+
+/** 窓の中の空白でない文字の過半が飾りなら、その出現は飾り。 */
+export const isFurniture = (text: string, mask: readonly boolean[], window: Span): boolean => {
+  const visible = Array.from({ length: window.end - window.start }, (_, step) => window.start + step).filter((index) => !/\s/u.test(text[index] ?? ""));
+  const marked = visible.filter((index) => mask[index] === true);
+  return visible.length > 0 && marked.length * 2 > visible.length;
+};

package/src/detectors/gram-place.ts

@@ -37,12 +37,16 @@ export const compacted = (text: string, unit: LengthUnit): Compacted => {
   return { text: chars.join(""), offsets };
 };
 
+/** 詰めた文の中の範囲を、元の文の範囲に戻す。 */
+export const placeAt = (source: Compacted, window: Span): Span | undefined => {
+  const start = source.offsets[window.start];
+  const last = source.offsets[window.end - 1];
+  if (start === undefined || last === undefined) return undefined;
+  return { start, end: last + 1 };
+};
+
 /** 詰めた文の中の gram の最初の出現を、元の文の範囲に戻す。無ければ undefined。 */
 export const placeOf = (source: Compacted, gram: string): Span | undefined => {
   const at = source.text.indexOf(gram);
-  if (at === -1) return undefined;
-  const start = source.offsets[at];
-  const last = source.offsets[at + gram.length - 1];
-  if (start === undefined || last === undefined) return undefined;
-  return { start, end: last + 1 };
+  return at === -1 ? undefined : placeAt(source, { start: at, end: at + gram.length });
 };

package/src/detectors/gram-windows.ts

@@ -0,0 +1,31 @@
+import type { Span } from "../plugin.ts";
+
+/** 1 文字ずつずらした、幅 width の窓。 */
+export const charWindows = (text: string, width: number): Span[] =>
+  Array.from({ length: Math.max(0, text.length - width + 1) }, (_, start) => ({ start, end: start + width }));
+
+/** first 番目の語から数えて、minLength 文字に届く最初の語。届く前に尽きるのは minLength 文字に満たない末尾だけなので、深くならない。 */
+const reachingWord = (words: readonly Span[], first: number, minLength: number): Span | undefined => {
+  const start = words[first]?.start ?? 0;
+  const step = (index: number): Span | undefined => {
+    const word = words[index];
+    if (word === undefined || word.end - start >= minLength) return word;
+    return step(index + 1);
+  };
+  return step(first);
+};
+
+/** 語。前後の句読点と括弧は含めない。"described," と "described" を別の語句として数えないため。 */
+const WORD = /[\p{L}\p{N}](?:\S*[\p{L}\p{N}])?/gu;
+
+/**
+ * 語の頭で始まり語の尾で終わる窓。語を 1 つずつ足して、minLength 文字に届いた最短のもの。
+ * 文字で切ると " generat" や "roductivity change a" のような語の断片が数えられる。
+ */
+export const wordWindows = (text: string, minLength: number): Span[] => {
+  const words = [...text.matchAll(WORD)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+  return words.flatMap((first, index) => {
+    const last = reachingWord(words, index, minLength);
+    return last === undefined ? [] : [{ start: first.start, end: last.end }];
+  });
+};

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,6 +1,7 @@
 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";
@@ -37,12 +38,15 @@ const NEW_MATERIAL = { word: 6, char: 20 };
  */
 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;
   if (unit === "char" && first.tokens !== undefined && section.headingTokens !== undefined)
-    return newContentMorphemes(section.headingTokens, first.tokens) <= NEW_CONTENT_MORPHEMES;
-  return lengthOf(first, unit) - echoedHeadingUnits(section.heading, proseText(first), unit) <= NEW_MATERIAL[unit];
+    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];
 };
 
 /** 最初の文が、同じ節の後ろ（箇条書き・表・コード）へ読者を渡している。 */
@@ -52,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/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

@@ -19,7 +19,28 @@ import { aiTell, contractionMix, cushionDensity, hedging, repeatedConjunction, u
 import { internalJargon, properNounDensity, requiredSections } from "./team.ts";
 import { latinSpacing, preferredTerm } from "./orthography.ts";
 import { straySpace } from "./stray-space.ts";
-import { danglingReference, dateOrder, dateWeekdayMismatch, duplicateDefinition, numberingGap, totalMismatch } from "./structure-tree.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>> = {
@@ -58,6 +79,12 @@ 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,
@@ -65,10 +92,25 @@ export const DETECTORS: Readonly<Record<string, Detector>> = {
   "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/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);
 };