chaffjs 0.18.0 → 0.20.0

package/src/detectors/orthographic-variant.ts

@@ -0,0 +1,152 @@
+import type { Detector, Finding, ProseDocument, Sentence, Token } from "../plugin.ts";
+import { groupBy, oddSpellings, type KeyedWord, type OddSpelling } from "../spelling-variants.ts";
+import { kanjiSkeleton, katakanaKey, lemmaReading } from "../kana-spelling.ts";
+import { isKatakanaWord, stemOf } from "../long-vowel.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+import { nameSpans, touchesAny } from "../team-names.ts";
+
+/** A word found in the document: where it is, which sentence it is in, its key and spelling, and how it is written when that differs. */
+type Placed = KeyedWord & { readonly sentence: Sentence; readonly offset: number; readonly shown?: string };
+
+type IsOpen = (start: number, end: number) => boolean;
+
+/** Parts of speech that carry a word of their own. Particles and endings are written one way by the grammar. */
+const CONTENT = new Set(["NOUN", "VERB", "ADJ", "ADV", "PRON", "CCONJ", "DET"]);
+const JAPANESE_WORD = /^[\p{Script=Han}々ぁ-ゖァ-ヺー]+$/u;
+/** A one-mora reading (木 and き, 気) is too short to say two spellings are one word. */
+const MIN_READING = 2;
+/** A katakana key shorter than this meets other words (ビル and ビール). */
+const MIN_KATAKANA_KEY = 4;
+const MIN_LATIN_KEY = 3;
+
+/** Lexicons: readings and spellings whose kanji and kana forms mean different things (成る and なる, 者 and もの), and adverbs hiragana-fukushi reads. */
+const DISTINCT = "orthographic-variant-distinct";
+const FUKUSHI = "hiragana-fukushi";
+
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** Whether a stretch of the sentence is outside a quotation and outside the team's names, both of which keep their own spelling. */
+const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
+  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const named = nameSpans(sentence.text, names);
+  return (start, end) => !isWithinAny(quoted, { start, end }) && !touchesAny(named, start, end);
+};
+
+const isHelper = (token: Token, previous: Token | undefined): boolean =>
+  token.features?.["Bound"] === "Yes" || (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で"));
+
+/**
+ * A helper verb or a dependent noun (見て下さい, その事) is written kana by many guides while the full word keeps its kanji (資料を下さい).
+ * The two uses are compared apart, so a document that follows that convention is consistent. A suffix (業務用) is a third use:
+ * it is not the dependent noun of the same reading (このように).
+ */
+const useOf = (token: Token, previous: Token | undefined): string => {
+  if (!isHelper(token, previous)) return "free";
+  return token.pos === "NOUN" && token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
+};
+
+const readingKeyOf = (token: Token, previous: Token | undefined, skip: ReadonlySet<string>): string | undefined => {
+  const lemma = token.lemma;
+  if (!CONTENT.has(token.pos) || token.reading === undefined || lemma === undefined || !JAPANESE_WORD.test(lemma) || skip.has(lemma)) return undefined;
+  const reading = lemmaReading(token.surface, lemma, token.reading);
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading)) return undefined;
+  return `${token.pos}|${useOf(token, previous)}|${reading}`;
+};
+
+/** Japanese words keyed by part of speech, use and the reading of the dictionary form, spelled as the dictionary form. */
+const readingWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const tokens = sentence.tokens ?? [];
+  return tokens.flatMap((token, at): Placed[] => {
+    const key = readingKeyOf(token, tokens[at - 1], skip);
+    const local = token.span.start - sentence.span.start;
+    if (key === undefined || token.lemma === undefined || !isOpen(local, local + token.surface.length)) return [];
+    return [{ key, spelling: token.lemma, sentence, offset: token.span.start }];
+  });
+};
+
+/**
+ * Same reading is not yet same word: 書く and 描く are both カク. Spellings meet only when they keep the same kanji (引っ越し, 引越し)
+ * or one is all kana. A kana spelling joins the kanji one only when the reading has a single kanji spelling in the document;
+ * with two (橋 and 箸 beside はし) it cannot say which, and is left out.
+ */
+const byKanji = (words: readonly Placed[]): Placed[] =>
+  [...groupBy(words, (word) => word.key).values()].flatMap((group) => {
+    const skeletons = [...new Set(group.map((word) => kanjiSkeleton(word.spelling)).filter((skeleton) => skeleton !== ""))];
+    return group.flatMap((word): Placed[] => {
+      const own = kanjiSkeleton(word.spelling);
+      if (own === "" && skeletons.length > 1) return [];
+      return [{ ...word, key: `${word.key}|${own === "" ? (skeletons[0] ?? "") : own}` }];
+    });
+  });
+
+/** Katakana nouns keyed with small kana and ー evened out, spelled without the final ー that katakana-long-vowel reads. */
+const katakanaWords = (sentence: Sentence, isOpen: IsOpen): Placed[] =>
+  (sentence.tokens ?? []).flatMap((token): Placed[] => {
+    const local = token.span.start - sentence.span.start;
+    if (token.pos !== "NOUN" || !isKatakanaWord(token.surface) || !isOpen(local, local + token.surface.length)) return [];
+    const key = katakanaKey(token.surface);
+    return [...key].length < MIN_KATAKANA_KEY ? [] : [{ key: `kana|${key}`, spelling: stemOf(token.surface), sentence, offset: token.span.start }];
+  });
+
+const LATIN_WORD = /[A-Za-z][A-Za-z0-9]*(?:-[A-Za-z0-9]+)*/gu;
+const LOWER = /\p{Ll}/u;
+
+/**
+ * The case of the first letter of each part is left out of the spelling: a sentence, a title or a name gives it (Email and email,
+ * Long-Term and long-term), the writer does not. Capitals after it are the spelling (GitHub and Github).
+ */
+const latinSpelling = (word: string): string =>
+  word
+    .split("-")
+    .map((part) => part.charAt(0).toLowerCase() + part.slice(1))
+    .join("-");
+
+/** A word joined to a dot, an at sign or a slash is part of an address or a file name (github.com, user@example), spelled as it must be. */
+const ADDRESS_NEIGHBOUR = /[.@/\\_]/u;
+
+const isPartOfAddress = (text: string, start: number, end: number): boolean =>
+  ADDRESS_NEIGHBOUR.test(text.charAt(start - 1)) || (ADDRESS_NEIGHBOUR.test(text.charAt(end)) && /\w/u.test(text.charAt(end + 1)));
+
+/**
+ * Latin words keyed without hyphens and case (e-mail and email, GitHub and Github). A word in capitals only (TEAMS, MAY) is
+ * emphasis or an acronym, not a spelling of the word, and is left out.
+ */
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
+  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+    const word = match[0];
+    const plain = word.toLowerCase().replaceAll("-", "");
+    const end = match.index + word.length;
+    if (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || skip.has(word.toLowerCase())) return [];
+    if (isPartOfAddress(sentence.text, match.index, end) || !isOpen(match.index, end)) return [];
+    return [{ key: `latin|${plain}`, spelling: latinSpelling(word), shown: word, sentence, offset: sentence.span.start + match.index }];
+  });
+
+/** How the usual spelling is written where it first appears (gitHub is shown GitHub). */
+const shownUsual = (words: readonly Placed[], { word, usual }: OddSpelling<Placed>): string =>
+  words.find((other) => other.key === word.key && other.spelling === usual)?.shown ?? usual;
+
+const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: odd.word.sentence.text.trim(),
+  values: { written: odd.word.shown ?? odd.word.spelling, other: shownUsual(words, odd), count: odd.count, of: odd.of, offset: odd.word.offset },
+});
+
+/**
+ * One word written two ways in one document (出来る and できる, 引っ越し and 引越し, ウィンドウ and ウインドウ, e-mail and email),
+ * found without a list of words: the document's own words are grouped by reading or by an evened-out spelling, and the way the
+ * document writes less is pointed at. No way is called right; limit is the largest share, in percent, the minority may have.
+ */
+export const orthographicVariant: Detector = (doc, options): Finding[] => {
+  const skip = new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]);
+  const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skip)));
+  const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
+  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skip));
+  const odd = [reading, katakana, latin].flatMap((words) => oddSpellings(words, options.limit));
+  const all = [...reading, ...katakana, ...latin];
+  // A word can be odd by its reading and by its katakana key at once; one place is said once.
+  return [...new Map(odd.map((entry) => [entry.word.offset, entry])).values()].map((entry) => findingOf(all, entry));
+};

package/src/detectors/orthography.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument, Sentence, Span } from "../plugin.ts";
 import { calendarRuns, calendarUnitsOf, type CalendarUnits } from "../calendar-number.ts";
-import { latinBoundaries, minorityStyle, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { escapeRegExp, latinBoundaries, occurrencesOutside, type Boundary, type SpacingKind } from "../orthography.ts";
+import { minorityReport } from "../spacing-minority.ts";
 import { isWithinAny, quotedSpans } from "../quoted-span.ts";
 import { digitRunAround, endsWithDivisionLabel, isNumberName, sequenceLabelStarts, type NameContext } from "../number-name.ts";
 
@@ -36,17 +37,43 @@ const digitBeside = (boundary: Boundary): number => {
  * 文書全体で一度だけ読むもの（number-name.ts の NameContext に加えて）。calendar は日付・時刻の単位、
  * divisions は「第1節」のように「第」と番号の後ろに書く区切りの語。
  */
-type NumberContext = NameContext & { readonly calendar: CalendarUnits; readonly divisions: ReadonlySet<string> };
+type NumberContext = NameContext & {
+  readonly calendar: CalendarUnits;
+  readonly divisions: ReadonlySet<string>;
+  readonly itemNumbers: ReadonlySet<string>;
+};
+
+/** 文頭の項目の番号の後ろと見る境目の位置の上限。番号は短く文の頭にあるので、これより後ろの境目は番号の後ろではない。長い文で文頭からの切り出しを繰り返さない。 */
+const ITEM_NUMBER_REACH = 8;
+
+/** 行の頭の字下げと箇条書きの印。 */
+const ITEM_LEAD = /^[\s\-*+]*/u;
+
+/**
+ * 文書が項目の番号として行の頭に並べたもの（語彙表 item-number は並びの順）。行の頭に空白で本文と区切って書かれ、
+ * 前か次の番号も同じように書かれているものだけ。「一」「二」は番号、前後の無い「十 GBまで」の十は数量。
+ */
+const numberedItems = (ordered: readonly string[], source: string): ReadonlySet<string> => {
+  if (ordered.length === 0) return new Set();
+  const labels = ordered.toSorted((left, right) => right.length - left.length).map(escapeRegExp);
+  const atHead = new Set([...source.matchAll(new RegExp(`^[ \\t\\-*+]*(${labels.join("|")})[ \\u3000]`, "gmu"))].map((match) => match[1]));
+  return new Set(ordered.filter((label, at) => atHead.has(label) && (atHead.has(ordered[at - 1]) || atHead.has(ordered[at + 1]))));
+};
+
+/** 境目が、文頭の項目の番号と本文を分ける空白か（「一 JIS」）。 */
+const followsItemNumber = (text: string, boundary: Boundary, itemNumbers: ReadonlySet<string>): boolean =>
+  boundary.spaced && boundary.offset <= ITEM_NUMBER_REACH && itemNumbers.has(text.slice(0, boundary.offset).replace(ITEM_LEAD, ""));
 
 /** 文の中の日付・時刻の数の、並びの頭の位置。 */
 const calendarStarts = (sentence: Sentence, units: CalendarUnits): ReadonlySet<number> =>
   new Set(calendarRuns(sentence.text, sentence.tokens, sentence.span.start, units).map(({ run }) => run.start));
 
 /**
- * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目は、空け方の好みではないので数えない。
+ * 番号・識別子として書かれた数（number-name.ts）、日付・時刻の数、「第1節」の後ろの境目、文頭の項目の番号（「一 JIS」）の後ろの境目は、空け方の好みではないので数えない。
  * 日付・時刻は前の境目（「は 9月」「午後3時」「令和 3 年」）も数えない。日付はまとめて一つの書き方で、数量の空け方の票にはしない。
  */
 const isCounted = (sentence: Sentence, boundary: Boundary, context: NumberContext, calendar: ReadonlySet<number>): boolean => {
+  if (followsItemNumber(sentence.text, boundary, context.itemNumbers)) return false;
   if (boundary.kind !== "after-digit" && endsWithDivisionLabel(sentence.text.slice(0, boundary.offset), context.divisions)) return false;
   if (boundary.kind === "letter") return true;
   const run = digitRunAround(sentence.text, digitBeside(boundary));
@@ -68,6 +95,43 @@ const labelsAt = (doc: ProseDocument, position: "before" | "after"): ReadonlySet
  */
 const isQuoted = (quoted: readonly Span[], boundary: Boundary): boolean => isWithinAny(quoted, { start: boundary.offset, end: boundary.offset });
 
+/**
+ * リンクの文字の中の境目。リンクの文字は引いた記事や資料の題であることが多く、空け方は元のものなので、鉤括弧の中と同じに数えない。
+ * リンクの外側の端（「を [記事]」の空白）は書き手の空け方なので数える。at は文書全体の位置。
+ */
+const isInsideLink = (links: readonly Span[], at: number): boolean => links.some((link) => link.start < at && at < link.end);
+
+const findingAt = (entry: Located, values: Finding["values"], variant?: string): Finding => ({
+  rule: "",
+  severity: "warning",
+  line: 0,
+  column: 0,
+  quote: entry.sentence.text.trim(),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset: entry.sentence.span.start + entry.offset },
+});
+
+/** 一つの種類の境目の指摘。少ないほうを 1 箇所ずつか、書き方が二通りあれば 1 件で（spacing-minority.ts）。 */
+const findingsOf = (kind: SpacingKind, ofKind: readonly Located[], limit: number): Finding[] => {
+  const report = minorityReport(ofKind, limit);
+  if (report === undefined) return [];
+  if (report.mode === "mixed") {
+    const { first, odd, spaced, touching } = report;
+    return [findingAt(first, { kind: KIND_NAME[kind], spaced, touching, count: odd, of: ofKind.length, limit }, "mixed")];
+  }
+  const minority = report.odd[0]?.spaced ?? false;
+  return report.odd.map((entry) =>
+    findingAt(entry, {
+      kind: KIND_NAME[kind],
+      style: minority ? "空けています" : "詰めています",
+      usual: minority ? "詰める" : "空ける",
+      count: report.odd.length,
+      of: ofKind.length,
+      limit,
+    }),
+  );
+};
+
 /**
  * 日本語と英字・数字のあいだを、空けるか詰めるか。文書の中で混ざっていたら、少ないほうを指摘する。
  * どちらが正しいかは決めない。決めるのはチームで、chaff はそろっているかだけを見る。
@@ -80,35 +144,21 @@ export const latinSpacing: Detector = (doc, options): Finding[] => {
     labelWords: labelsAt(doc, "before"),
     calendar: calendarUnitsOf(doc),
     divisions: labelsAt(doc, "after"),
+    itemNumbers: numberedItems(patternList(doc, "item-number"), doc.prose ?? doc.source),
   };
   const located: Located[] = doc.sentences.flatMap((sentence) => {
     const quoted = quotedSpans(sentence.text);
     const calendar = calendarStarts(sentence, context.calendar);
     return latinBoundaries(sentence.text, doc.source.slice(sentence.span.start, sentence.span.end))
-      .filter((boundary) => !isQuoted(quoted, boundary) && isCounted(sentence, boundary, context, calendar))
+      .filter((boundary) => !isQuoted(quoted, boundary) && !isInsideLink(doc.links, sentence.span.start + boundary.offset))
+      .filter((boundary) => isCounted(sentence, boundary, context, calendar))
       .map((boundary) => ({ sentence, ...boundary }));
   });
-  return KINDS.flatMap((kind) => {
-    const ofKind = located.filter((entry) => entry.kind === kind);
-    const minority = minorityStyle(ofKind);
-    if (minority === undefined) return [];
-    const odd = ofKind.filter((entry) => entry.spaced === minority);
-    if (odd.length < options.limit) return [];
-    return odd.map((entry) => ({
-      rule: "",
-      severity: "warning",
-      line: 0,
-      column: 0,
-      quote: entry.sentence.text.trim(),
-      values: {
-        kind: KIND_NAME[kind],
-        style: minority ? "空けています" : "詰めています",
-        usual: minority ? "詰める" : "空ける",
-        count: odd.length,
-        of: ofKind.length,
-        limit: options.limit,
-        offset: entry.sentence.span.start + entry.offset,
-      },
-    }));
-  });
+  return KINDS.flatMap((kind) =>
+    findingsOf(
+      kind,
+      located.filter((entry) => entry.kind === kind),
+      options.limit,
+    ),
+  );
 };

package/src/detectors/outside-announced-list.ts

@@ -0,0 +1,25 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { listStatementsIn, outsideMembers } from "../announced-list.ts";
+import { linesOf, lineNumberAt } from "../structure/lines.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+/** 最初に挙げた一覧（対応 OS は Windows と macOS）に無い名前を、後の文が同じ語で言う所（Linux にも対応）。 */
+export const outsideAnnouncedList: Detector = (doc): Finding[] => {
+  const lowered = (id: string): Set<string> => new Set((doc.lexicons[id] ?? []).map((entry) => entry.pattern.toLowerCase()));
+  const words = { frames: doc.lexicons["enumeration-frame"] ?? [], joiners: lowered("enumeration-joiner"), negations: lowered("enumeration-negation") };
+  const statements = doc.sentences.flatMap((sentence) => listStatementsIn(sentence, words, doc.source));
+  const lines = linesOf(doc.source);
+  return outsideMembers(statements).map(({ member, announced }) => ({
+    rule: "",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, member.offset),
+    values: {
+      name: member.name,
+      list: announced.members.map((listed) => listed.name).join(", "),
+      listLine: lineNumberAt(lines, announced.offset) ?? 0,
+      offset: member.offset,
+    },
+  }));
+};

package/src/detectors/oxford-comma.ts

@@ -274,6 +274,7 @@ export const oxfordComma: Detector = (doc, options): Finding[] => {
     participle: patternsOf(doc.lexicons["participle-word"]),
     example: doc.lexicons["example-marker"] ?? [],
     pair: patternsOf(doc.lexicons["pair-opener"]),
+    region: doc.lexicons["place-region"] ?? [],
   };
   const judged = doc.sentences.flatMap((sentence) => {
     const oxford = oxfordIn(sentence.tokens ?? [], words, doc.source);

package/src/detectors/paragraph-restatement.ts

@@ -0,0 +1,68 @@
+// A paragraph that announces a restatement (つまり, このように, In other words) and then mostly repeats the paragraph
+// before it. Pure; measured in content morphemes by base form, the way heading-echo measures a heading. The announcing
+// words come from the language's restating-opener lexicon.
+import { newContentMorphemes } from "./content-morphemes.ts";
+import type { Detector, Finding, Paragraph, ProseDocument, Token } from "../plugin.ts";
+
+/** A paragraph with fewer content words than this says too little to measure. */
+const MIN_CONTENT_WORDS = 4;
+
+const PERCENT = 100;
+
+/** What may follow the opener: a comma, a space or the end; in Japanese also the next word straight away (つまり実行時に). */
+const AFTER_OPENER = /^(?:$|[\s、，,:：]|[^\p{Script=Latin}])/u;
+
+/** The opener a paragraph starts with, as written, or undefined. Case is folded; the longest opener wins. */
+export const openerOf = (text: string, openers: readonly string[]): string | undefined => {
+  const trimmed = text.trimStart();
+  const folded = trimmed.toLowerCase();
+  const found = openers
+    .filter((opener) => folded.startsWith(opener.toLowerCase()) && AFTER_OPENER.test(trimmed.slice(opener.length)))
+    .toSorted((left, right) => right.length - left.length)[0];
+  return found === undefined ? undefined : trimmed.slice(0, found.length);
+};
+
+/** The share of the later tokens' content words, in percent, that the earlier tokens already hold (by base form). */
+export const repeatedShare = (earlier: readonly Token[], later: readonly Token[]): { readonly share: number; readonly words: number } => {
+  const words = newContentMorphemes([], later);
+  if (words === 0) return { share: 0, words };
+  return { share: Math.round(((words - newContentMorphemes(earlier, later)) / words) * PERCENT), words };
+};
+
+const tokensOf = (paragraph: Paragraph): Token[] => paragraph.sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/** The paragraph's tokens past its opener: the opener itself is not what the paragraph says. */
+const tokensAfterOpener = (paragraph: Paragraph, opener: string): Token[] => {
+  const [first, ...rest] = paragraph.sentences;
+  if (first === undefined) return [];
+  const openerEnd = first.text.length - first.text.trimStart().length + opener.length;
+  return [...(first.tokens ?? []).filter((token) => token.span.end > openerEnd), ...rest.flatMap((sentence) => sentence.tokens ?? [])];
+};
+
+/** Two paragraphs with only blank lines between: no heading, list, table or code separates them. */
+const isNextTo = (doc: ProseDocument, earlier: Paragraph, later: Paragraph): boolean => doc.source.slice(earlier.span.end, later.span.start).trim() === "";
+
+const findingOf = (paragraph: Paragraph, opener: string, share: number, limit: number): Finding => {
+  const first = paragraph.sentences[0];
+  const lead = first === undefined ? 0 : first.text.length - first.text.trimStart().length;
+  return {
+    rule: "paragraph-restatement",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: first?.text.trim() ?? "",
+    values: { opener, share, limit, offset: (first?.span.start ?? paragraph.span.start) + lead },
+  };
+};
+
+/** Each paragraph that opens with a restating word and repeats at least limit percent of the previous paragraph's words. */
+export const paragraphRestatement: Detector = (doc, options): Finding[] => {
+  const openers = (doc.lexicons["restating-opener"] ?? []).map((entry) => entry.pattern);
+  return doc.paragraphs.flatMap((later, index): Finding[] => {
+    const earlier = doc.paragraphs[index - 1];
+    const opener = openerOf(later.sentences[0]?.text ?? "", openers);
+    if (earlier === undefined || opener === undefined || !isNextTo(doc, earlier, later)) return [];
+    const { share, words } = repeatedShare(tokensOf(earlier), tokensAfterOpener(later, opener));
+    return words >= MIN_CONTENT_WORDS && share >= options.limit ? [findingOf(later, opener, share, options.limit)] : [];
+  });
+};

package/src/detectors/paragraph-run.ts

@@ -0,0 +1,27 @@
+import type { Detector, Finding } from "../plugin.ts";
+import { oneSentenceRuns } from "../paragraph-runs.ts";
+
+/** How much of the run's first paragraph the finding quotes. */
+const QUOTE_LENGTH = 80;
+
+/**
+ * Runs of one-sentence paragraphs longer than the limit: every sentence set apart as its own paragraph, so nothing is grouped
+ * and the reader cannot see which points belong together. One finding per run, at its first paragraph.
+ */
+export const oneSentenceParagraphRun: Detector = (doc, options): Finding[] =>
+  oneSentenceRuns(doc.source, doc.paragraphs)
+    .filter((run) => run.length > options.limit)
+    .flatMap((run) => {
+      const first = run[0];
+      if (first === undefined) return [];
+      return [
+        {
+          rule: "",
+          severity: "info",
+          line: 0,
+          column: 0,
+          quote: doc.source.slice(first.span.start, first.span.start + QUOTE_LENGTH).trim(),
+          values: { count: run.length, limit: options.limit, offset: first.span.start },
+        },
+      ];
+    });

package/src/detectors/person-consistency.ts

@@ -0,0 +1,29 @@
+import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
+import { personMentions, personMinorities, type PersonMention, type PersonWords } from "../person-forms.ts";
+
+const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords => ({
+  words,
+  forms: doc.lexicons["person-form"] ?? [],
+  notAfter: doc.lexicons["person-not-after"] ?? [],
+});
+
+/**
+ * One document naming itself (私たち / 弊社, 私 / 筆者) or its reader (you / one) two ways: the minority form of each slot.
+ * Sentences in another language than the document's are left out; quotations are left out by personMentions.
+ */
+export const personMix: Detector = (doc, options): Finding[] => {
+  const person = wordsOf(doc, options.lexicon ?? []);
+  const entries: { readonly sentence: Sentence; readonly mention: PersonMention }[] = doc.sentences
+    .filter((sentence) => sentence.embeddedLanguage === undefined)
+    .flatMap((sentence) => personMentions(sentence.text, person).map((mention) => ({ sentence, mention })));
+  return personMinorities(entries, options.limit).flatMap(({ odd, usual, of }) =>
+    odd.map(({ sentence, mention }) => ({
+      rule: "",
+      severity: "info" as const,
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: mention.written, usual, count: odd.length, of, limit: options.limit, offset: sentence.span.start + mention.at },
+    })),
+  );
+};

package/src/detectors/phrase-match.ts

@@ -1,5 +1,6 @@
 import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
-import { entryIn } from "./lexicon-match.ts";
+import { entryEnds, entryIn } from "./lexicon-match.ts";
+import { closingSentences } from "../closing-paragraph.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
 const OPENING_SENTENCES = 4;
@@ -10,7 +11,7 @@ const OPENING_SENTENCES = 4;
  */
 const inScope = (doc: ProseDocument, where: string | undefined): readonly Sentence[] => {
   if (where === "opening") return doc.sentences.slice(0, OPENING_SENTENCES);
-  if (where === "closing") return doc.sections.at(-1)?.sentences ?? [];
+  if (where === "closing") return closingSentences(doc.sections, doc.paragraphs);
   return doc.sentences;
 };
 
@@ -22,14 +23,14 @@ const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
-const findingsOf = (hits: readonly Hit[], limit: number): Finding[] =>
+const findingsOf = (hits: readonly Hit[], limit: number, count = hits.length): Finding[] =>
   hits.map((hit) => ({
     rule: "",
     severity: "warning",
     line: 0,
     column: 0,
     quote: hit.sentence.text.trim(),
-    values: { matched: hit.matched, count: hits.length, limit, offset: hit.sentence.span.start },
+    values: { matched: hit.matched, count, limit, offset: hit.sentence.span.start },
   }));
 
 const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
@@ -46,8 +47,27 @@ export const phraseMatch: Detector = (doc, options): Finding[] => {
   return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
 };
 
-/** 回数に上限がある語。limit は許す回数で、それを超えたときだけ言う。message の「N 回まで」と同じ向き。 */
+type Uses = { readonly sentence: Sentence; readonly matched: string; readonly count: number };
+
+/**
+ * 文の中の出現の数。語彙の語が重なっても（「させていただく」と「せていただく」）、終わる位置が同じなら一回。
+ * 指摘が言う語は文の最初の出現のもの。同じ位置なら語彙表で先に書いた語（させていただく）。
+ */
+const usesIn = (sentence: Sentence, lexicon: Lexicon): Uses | undefined => {
+  const found = lexicon.map((entry) => ({ entry, ends: entryEnds(sentence, entry) })).filter(({ ends }) => ends.length > 0);
+  const first = found.toSorted((a, b) => Math.min(...a.ends) - Math.min(...b.ends))[0];
+  if (first === undefined) return undefined;
+  return { sentence, matched: first.entry.pattern, count: new Set(found.flatMap(({ ends }) => ends)).size };
+};
+
+/**
+ * 回数に上限がある語。数えるのは文ではなく出現で、一文に二度あれば二回。limit は許す回数で、それを超えたときだけ言う。
+ * message の「N 回まで」と同じ向き。指摘は出現のある文ごとに一つ。
+ */
 export const phraseCount: Detector = (doc, options): Finding[] => {
-  const hits = phraseHits(doc, options);
-  return hits.length <= options.limit ? [] : findingsOf(hits, options.limit);
+  const lexicon = options.lexicon ?? [];
+  const uses = inScope(doc, options.where).flatMap((sentence) => usesIn(sentence, lexicon) ?? []);
+  const total = uses.reduce((sum, use) => sum + use.count, 0);
+  if (total <= options.limit) return [];
+  return findingsOf(uses, options.limit, total);
 };

package/src/detectors/placeholder-text.ts

@@ -5,12 +5,31 @@ type Span = { readonly start: number; readonly end: number };
 /** 雛形の空欄を囲む括弧。記号の形で、どの言語でも同じ。 */
 const BRACKETED = /\[([^[\]\n]{1,60})\]|【([^【】\n]{1,30})】|［([^［］\n]{1,30})］/gu;
 
+/** 書き手への指示を囲む丸括弧（（ここに会社名を書く））。丸括弧は説明にも使うので、語彙表の instruction の語で始まるときだけ数える。 */
+const PARENTHESIZED = /\(([^()\n]{1,60})\)|（([^（）\n]{1,60})）/gu;
+
 /**
  * 括弧のすぐ後ろ。Markdown のリンク（[text](url)、[text][ref]）と参照の定義（[ref]: url）、
  * 値が続く見出しの札（【氏名】山田、【日付】2024年）は空欄ではない。助詞（【会社名】の）や空白・句読点が続くなら空欄。
  */
 const FILLED_AFTER = /^[([:：\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}]/u;
 
+/** What may stand around a marker that is the whole value: quotes and brackets, a closing stop. */
+const OPENING = /^[\s"'“‘「『(（[［【]*/u;
+const CLOSERS: ReadonlySet<string> = new Set("\"'”’」』)）]］】.。!！");
+const COLON_NEXT = /^\s*[:：]/u;
+
+/** text without the quotes, brackets, stops and spaces that close it. */
+const withoutClosers = (text: string): string => {
+  const chars = [...text];
+  const last = chars.findLastIndex((char) => !CLOSERS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+/** Lexicon groups of placeholder-word. An entry without a group is a word written inside a template's brackets. */
+const MARKER = "marker";
+const INSTRUCTION = "instruction";
+
 const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
 
 /** 括弧の中身が語彙表の語そのものか、その語で始まって空白・アポストロフィが続くか（[Your Name]、[Insert Date]）。 */
@@ -20,8 +39,46 @@ const holdsWord = (inner: string, words: Lexicon): boolean =>
     return inner === pattern || (inner.startsWith(pattern) && /^[\s'’]/u.test(inner.slice(pattern.length)));
   });
 
-/** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】）の範囲。words は空欄に書く語。 */
-export const placeholderSpans = (text: string, words: Lexicon): Span[] =>
-  [...text.matchAll(BRACKETED)]
-    .filter((match) => !FILLED_AFTER.test(text.slice(match.index + match[0].length)) && holdsWord(innerOf(match), words))
-    .map((match) => ({ start: match.index, end: match.index + match[0].length }));
+/** 括弧の中身が指示の書き出しで始まるか（ここに会社名を書く）。 */
+const opensWith = (inner: string, words: Lexicon): boolean => words.some((word) => inner.startsWith(word.pattern.toLowerCase()));
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const bracketedSpans = (text: string, pattern: RegExp, holds: (inner: string) => boolean): Span[] =>
+  [...text.matchAll(pattern)].filter((match) => !FILLED_AFTER.test(text.slice(match.index + match[0].length)) && holds(innerOf(match))).map(spanOf);
+
+/**
+ * A value left as a marker: the whole text is the marker ("TBD", 「未定」), or the marker opens it before a colon
+ * ("TBD: owner"), in any case. Only the start of a value counts, so a marker word inside a sentence is not one.
+ * The span runs to the end of the value, quotes and the closing stop left out, so the finding quotes the whole note.
+ * A checklist task ("[ ] TBD: …") and a comment ("// TBD") keep their mark in front, so the marker does not open them.
+ */
+const markerSpans = (text: string, markers: Lexicon): Span[] => {
+  const start = OPENING.exec(text)?.[0].length ?? 0;
+  const rest = text.slice(start);
+  const marker = markers.find((entry) => rest.toLowerCase().startsWith(entry.pattern.toLowerCase()));
+  if (marker === undefined) return [];
+  const after = rest.slice(marker.pattern.length);
+  if (withoutClosers(after) === "") return [{ start, end: start + marker.pattern.length }];
+  if (!COLON_NEXT.test(after)) return [];
+  return [{ start, end: start + withoutClosers(rest).length }];
+};
+
+/** Each line of a sentence on its own: values a line apart ("TBD: owner" then "TBD: date") are two blanks, not one. */
+const lineMarkerSpans = (text: string, markers: Lexicon): Span[] =>
+  text.split("\n").flatMap((line, index, lines) => {
+    const offset = lines.slice(0, index).reduce((sum, previous) => sum + previous.length + 1, 0);
+    return markerSpans(line, markers).map((span) => ({ start: span.start + offset, end: span.end + offset }));
+  });
+
+/** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】、（ここに会社名を書く）、TBD: …）の範囲。words は placeholder-word の語彙表。 */
+export const placeholderSpans = (text: string, words: Lexicon): Span[] => {
+  const bracketWords = words.filter((word) => word.group === undefined);
+  const instructions = words.filter((word) => word.group === INSTRUCTION);
+  const markers = words.filter((word) => word.group === MARKER);
+  return [
+    ...bracketedSpans(text, BRACKETED, (inner) => holdsWord(inner, bracketWords)),
+    ...(instructions.length === 0 ? [] : bracketedSpans(text, PARENTHESIZED, (inner) => opensWith(inner, instructions))),
+    ...lineMarkerSpans(text, markers),
+  ].toSorted((left, right) => left.start - right.start);
+};

package/src/detectors/ra-nuki.ts

@@ -0,0 +1,38 @@
+import type { Detector, Finding, Sentence, Span, Token } from "../plugin.ts";
+import { QUOTATION_MARKS, isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** 言語アダプタが、ら抜き言葉の一部の語に付ける印（lang-ja の PotentialRa=Dropped）。 */
+const isRaDropped = (token: Token): boolean => token.features?.["PotentialRa"] === "Dropped";
+
+/** 印の付いた語が続く並び（「食べ」「れる」）を一つにまとめた、文書の中の範囲。 */
+const markedRuns = (tokens: readonly Token[]): Span[] =>
+  tokens.reduce<Span[]>((runs, token, index) => {
+    if (!isRaDropped(token)) return runs;
+    const last = runs.at(-1);
+    const previous = tokens[index - 1];
+    if (last !== undefined && previous !== undefined && isRaDropped(previous)) return [...runs.slice(0, -1), { start: last.start, end: token.span.end }];
+    return [...runs, token.span];
+  }, []);
+
+export type RaDroppedWord = { readonly written: string; readonly offset: number };
+
+/** 文の中のら抜き言葉。鉤括弧や引用符で引いた言葉（話した言葉をそのまま引いたもの）は数えない。 */
+export const raDroppedIn = (sentence: Sentence): RaDroppedWord[] => {
+  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  return markedRuns(sentence.tokens ?? [])
+    .map((run) => ({ start: run.start - sentence.span.start, end: run.end - sentence.span.start }))
+    .filter((run) => !isWithinAny(quoted, run))
+    .map((run) => ({ written: sentence.text.slice(run.start, run.end), offset: sentence.span.start + run.start }));
+};
+
+export const raNuki: Detector = (doc): Finding[] =>
+  doc.sentences.flatMap((sentence) =>
+    raDroppedIn(sentence).map((word) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { matched: word.written, offset: word.offset },
+    })),
+  );