chaffjs 0.25.0 → 0.27.0

package/src/detectors/orthographic-variant.ts

@@ -4,6 +4,8 @@ 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";
+import { furiganaSpans } from "../furigana.ts";
+import { acronymsIn, isCapitalsNotSpelling } from "../capitals-with-small.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 };
@@ -22,42 +24,82 @@ 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";
+/** Lexicon: idioms written as noun, particle and verb (気をつける). The verb there is compared apart from the verb on its own. */
+const IDIOM = "orthographic-variant-idiom";
 
 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. */
+/**
+ * Whether a stretch of the sentence is outside a quotation, the team's names and a reading in brackets (HTTP（えいちてぃーてぃーぴー）):
+ * the first two keep their own spelling, and a reading is not a spelling at all.
+ */
 const isOpenIn = (sentence: Sentence, names: readonly string[]): IsOpen => {
-  const quoted = quotedSpans(sentence.text, QUOTATION_MARKS);
+  const closed = [...quotedSpans(sentence.text, QUOTATION_MARKS), ...furiganaSpans(sentence.text)];
   const named = nameSpans(sentence.text, names);
-  return (start, end) => !isWithinAny(quoted, { start, end }) && !touchesAny(named, start, end);
+  return (start, end) => !isWithinAny(closed, { 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 word and the two words before it, in its sentence. */
+type InContext = { readonly token: Token; readonly previous: Token | undefined; readonly before: Token | undefined };
+
+/** A verb's て-form the tokenizer read as a conjunction (追って at the head of a sentence): a kanji stem and て or で. Connectives (そして, それで) are kana. */
+const TE_FORM_CONJUNCTION = /^\p{Script=Han}.*[てで]$/u;
+
+/** After a て-form (見てみる). The tokenizer reads the て as a joining word, or the whole て-form as a conjunction (追って / みる). */
+const followsTeForm = (previous: Token | undefined): boolean =>
+  (previous?.pos === "SCONJ" && (previous.surface === "て" || previous.surface === "で")) ||
+  (previous?.pos === "CCONJ" && TE_FORM_CONJUNCTION.test(previous.surface));
+
+const isHelper = ({ token, previous }: InContext): boolean => token.features?.["Bound"] === "Yes" || followsTeForm(previous);
+
+const isTouching = (left: Token | undefined, right: Token): boolean => left !== undefined && left.span.end === right.span.start;
+
+const HIRAGANA_ONLY = /^[ぁ-ゖー]+$/u;
+
+/** A kana noun written onto a noun (全員ぶん): a suffix, which may not be the free noun of the same reading (文). */
+const isKanaSuffix = ({ token, previous }: InContext): boolean =>
+  token.pos === "NOUN" && previous?.pos === "NOUN" && isTouching(previous, token) && HIRAGANA_ONLY.test(token.surface);
+
+/** The verb of an idiom (気をつける): the noun, the particle and the verb's dictionary form are in the idiom lexicon. */
+const isIdiomVerb = ({ token, previous, before }: InContext, idioms: ReadonlySet<string>): boolean =>
+  token.pos === "VERB" && previous?.pos === "ADP" && before !== undefined && idioms.has(`${before.surface}${previous.surface}${token.lemma ?? token.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 (このように).
+ * 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 (このように). The verb of an idiom (気をつける) is a fourth.
  */
-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 useOf = (word: InContext, idioms: ReadonlySet<string>): string => {
+  if (isIdiomVerb(word, idioms)) return "idiom";
+  if (isKanaSuffix(word)) return "suffix";
+  if (!isHelper(word)) return "free";
+  return word.token.pos === "NOUN" && word.token.features?.["NounType"] !== "Dependent" ? "suffix" : "bound";
 };
 
-const readingKeyOf = (token: Token, previous: Token | undefined, skip: ReadonlySet<string>): string | undefined => {
+/** One katakana and then kana that is not katakana (スる): no verb stem is one katakana long, as サボる and ググる are two. */
+const ONE_KATAKANA_HEAD = /^\p{Script=Katakana}(?!\p{Script=Katakana})/u;
+const KATAKANA_END = /\p{Script=Katakana}$/u;
+
+/** A piece the tokenizer cut out of a katakana run (ミスっ read as ミ and スる): not a word of its own. */
+const isCutFromKatakana = ({ token, previous }: InContext): boolean =>
+  ONE_KATAKANA_HEAD.test(token.surface) && token.surface.length > 1 && isTouching(previous, token) && KATAKANA_END.test(previous?.surface ?? "");
+
+type Skips = { readonly skip: ReadonlySet<string>; readonly idioms: ReadonlySet<string> };
+
+const readingKeyOf = (word: InContext, { skip, idioms }: Skips): string | undefined => {
+  const { token } = word;
   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}`;
+  if (reading === undefined || [...reading].length < MIN_READING || skip.has(reading) || isCutFromKatakana(word)) return undefined;
+  return `${token.pos}|${useOf(word, idioms)}|${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 readingWords = (sentence: Sentence, isOpen: IsOpen, skips: Skips): Placed[] => {
   const tokens = sentence.tokens ?? [];
   return tokens.flatMap((token, at): Placed[] => {
-    const key = readingKeyOf(token, tokens[at - 1], skip);
+    const key = readingKeyOf({ token, previous: tokens[at - 1], before: tokens[at - 2] }, skips);
     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 }];
@@ -109,17 +151,20 @@ const isPartOfAddress = (text: string, start: number, end: number): boolean =>
 
 /**
  * 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.
+ * emphasis or an acronym, not a spelling of the word, and is left out; so are a name in capitals with an ending (SENDs) and
+ * the letters of an acronym of the sentence picked out (CLImatology for CLIPER).
  */
-const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] =>
-  [...sentence.text.matchAll(LATIN_WORD)].flatMap((match): Placed[] => {
+const latinWords = (sentence: Sentence, isOpen: IsOpen, skip: ReadonlySet<string>): Placed[] => {
+  const acronyms = acronymsIn(sentence.text);
+  return [...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 (plain.length < MIN_LATIN_KEY || !LOWER.test(word) || isCapitalsNotSpelling(word, acronyms) || 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 =>
@@ -140,11 +185,11 @@ const findingOf = (words: readonly Placed[], odd: OddSpelling<Placed>): Finding
  * 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 skips: Skips = { skip: new Set([...patternsOf(doc, DISTINCT), ...patternsOf(doc, FUKUSHI)]), idioms: new Set(patternsOf(doc, IDIOM)) };
   const placed = doc.sentences.map((sentence) => ({ sentence, isOpen: isOpenIn(sentence, doc.names ?? []) }));
-  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skip)));
+  const reading = byKanji(placed.flatMap(({ sentence, isOpen }) => readingWords(sentence, isOpen, skips)));
   const katakana = placed.flatMap(({ sentence, isOpen }) => katakanaWords(sentence, isOpen));
-  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skip));
+  const latin = placed.flatMap(({ sentence, isOpen }) => latinWords(sentence, isOpen, skips.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.

package/src/detectors/party-role-name.ts

@@ -0,0 +1,44 @@
+// A party called by a role word (受託者, the Vendor) after the contract gave it a short name (乙, the "Supplier"). The
+// definitions come from the document's structure tree; the role words, short names and company forms from the language
+// package's word lists (party-role, party-short-name, company-form).
+import { definedTerms } from "../structure/definition-use.ts";
+import { partiesOf, roleUses } from "../structure/party-role.ts";
+import { quoteAt } from "./structure-tree.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** The sentence holding a definition: the role words in the sentences that name the parties are part of naming them. */
+const sentenceAt = (doc: ProseDocument, offset: number): { readonly start: number; readonly end: number } =>
+  doc.sentences.find((sentence) => sentence.span.start <= offset && offset < sentence.span.end)?.span ?? { start: offset, end: offset };
+
+const NAME_SEPARATOR: Readonly<Record<string, string>> = { ja: "、" };
+
+export const partyRoleName: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const terms = definedTerms(doc.structure);
+  const words = { roles: patternsOf(doc, "party-role"), shortNames: patternsOf(doc, "party-short-name"), companyForms: patternsOf(doc, "company-form") };
+  const parties = partiesOf(doc.source, terms, words);
+  if (parties.length === 0) return [];
+  // From the sentence that names the first party: a party named later (a subcontractor ("Recipient")) does not hide the role words before it.
+  const naming = parties.map((party) => sentenceAt(doc, party.end - 1));
+  const after = Math.min(...naming.map((sentence) => sentence.end));
+  const names = [...new Set(parties.map((party) => party.term))].join(NAME_SEPARATOR[doc.language] ?? ", ");
+  const texts = doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
+  return roleUses(
+    doc.source,
+    texts,
+    words.roles,
+    terms.map((term) => term.term),
+    after,
+  )
+    .filter((use) => !naming.some((sentence) => sentence.start <= use.offset && use.offset < sentence.end))
+    .map((use) => ({
+      rule: "party-role-name",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, use.offset),
+      values: { role: use.role, names, offset: use.offset },
+    }));
+};

package/src/detectors/quote-without-source.ts

@@ -0,0 +1,90 @@
+// A quotation the text gives to someone (「…」と述べている, according to X, "…") in a paragraph that names no source for it:
+// no link, no footnote or numbered citation, no year in brackets. Whether the words are really that person's is for
+// `chaff cite` against the source; this only says that there is nothing to check them against. The words that give a
+// quotation to someone come from the language package's word list quote-attribution. Pure.
+import { QUOTATION_MARKS, quotedSpans } from "../quoted-span.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type QuoteText = { readonly start: number; readonly text: string };
+
+export type QuoteParagraph = { readonly source: string; readonly sentences: readonly QuoteText[] };
+
+export type UnsourcedQuote = { readonly offset: number; readonly quote: string };
+
+/** Shorter than this, a quotation is a term or a label (「保存」, "Save"), not someone's words. */
+const MIN_QUOTE_CHARS = 10;
+
+/**
+ * A link, a bare URL, a footnote mark, a numbered citation ([3]) or a year that ends a bracket as a citation's does: alone
+ * ((1975), （1999年）), after a comma (（架空の本、1975年）) or after a name ((Brooks 1975)). Not (port 2000).
+ */
+const SOURCE_MARKS = [
+  /\]\(/u,
+  /https?:\/\//u,
+  /\[\^[^\]\s]+\]/u,
+  /\[\d{1,3}(?:[,，、–-]\s*\d{1,3})*\]/u,
+  /[（(](?:1[5-9]|20)\d\d[a-z]?年?[）)]/u,
+  /[（(][^（）()\n]*[,、，]\s*(?:1[5-9]|20)\d\d[a-z]?年?[）)]/u,
+  /[（(]\p{Lu}[^（）()\n]*\s(?:1[5-9]|20)\d\d[a-z]?[）)]/u,
+];
+
+/** How far before a quotation a cue may end ("According to the study, “…”", 先輩によれば「…」). */
+const CUE_REACH_BEFORE = 40;
+/** How far after a quotation a cue may start: a space ("“…,” said"), or none (「…」と述べた, not 「…」などと書く). */
+const CUE_REACH_AFTER = 1;
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+
+const namesSource = (paragraph: string): boolean => SOURCE_MARKS.some((mark) => mark.test(paragraph));
+
+const escaped = (word: string): string => word.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&");
+
+/**
+ * Where the cue stands in the sentence, ignoring case, in the sentence's own positions (lowercasing first would move them:
+ * İ becomes two units). An English cue is not read inside a longer word (says in essays).
+ */
+const cueStarts = (text: string, cue: string): number[] => {
+  if (cue === "") return [];
+  return [...text.matchAll(new RegExp(escaped(cue), "giu"))]
+    .map((match) => match.index)
+    .filter((at) => !LATIN.test(cue) || (!LETTER.test(text.charAt(at - 1)) && !LETTER.test(text.charAt(at + cue.length))));
+};
+
+type Quoted = { readonly start: number; readonly end: number };
+
+/** A cue just before the quotation's opening mark, or just after its closing mark. position says which side it may stand on. */
+const isAttributed = (text: string, quoted: Quoted, cues: readonly LexiconEntry[]): boolean =>
+  cues.some((cue) =>
+    cueStarts(text, cue.pattern).some((at) => {
+      const before = cue.position !== "after" && at + cue.pattern.length <= quoted.start - 1 && at + cue.pattern.length >= quoted.start - 1 - CUE_REACH_BEFORE;
+      const after = cue.position !== "before" && at >= quoted.end + 1 && at <= quoted.end + 1 + CUE_REACH_AFTER;
+      return before || after;
+    }),
+  );
+
+const quotesIn = (sentence: QuoteText, cues: readonly LexiconEntry[]): UnsourcedQuote[] => {
+  return quotedSpans(sentence.text, QUOTATION_MARKS)
+    .filter((span) => [...sentence.text.slice(span.start, span.end).trim()].length >= MIN_QUOTE_CHARS && isAttributed(sentence.text, span, cues))
+    .map((span) => ({ offset: sentence.start + span.start, quote: sentence.text.slice(span.start, span.end).trim() }));
+};
+
+/** Each quotation given to someone, in a paragraph that names no source. cues: the word list quote-attribution. */
+export const unsourcedQuotes = (paragraphs: readonly QuoteParagraph[], cues: readonly LexiconEntry[]): UnsourcedQuote[] =>
+  paragraphs.filter((paragraph) => !namesSource(paragraph.source)).flatMap((paragraph) => paragraph.sentences.flatMap((sentence) => quotesIn(sentence, cues)));
+
+export const quoteWithoutSource: Detector = (doc: ProseDocument): Finding[] =>
+  unsourcedQuotes(
+    doc.paragraphs.map((paragraph) => ({
+      source: doc.source.slice(paragraph.span.start, paragraph.span.end),
+      sentences: paragraph.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text })),
+    })),
+    doc.lexicons["quote-attribution"] ?? [],
+  ).map((hit) => ({
+    rule: "quote-without-source",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: hit.quote,
+    values: { quote: hit.quote, offset: hit.offset },
+  }));

package/src/detectors/reference-text.ts

@@ -12,7 +12,7 @@ const inputOf = (doc: ProseDocument): ReferenceInput | undefined => {
   return {
     source: doc.source,
     references: inDocumentOrder(tree).filter((node) => node.kind === "reference" && node.attrs["document"] === undefined),
-    targetOf: referenceResolver(tree),
+    targetOf: referenceResolver(tree, doc.source),
     words: {
       asides: patternsOf(doc, "reference-aside"),
       topicLinks: patternsOf(doc, "reference-topic-link"),

package/src/detectors/registry/change-rate.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { changeRate } from "../change-rate.ts";
+
+export const detector: Detector = changeRate;

package/src/detectors/registry/party-role-name.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { partyRoleName } from "../party-role-name.ts";
+
+export const detector: Detector = partyRoleName;

package/src/detectors/registry/quote-without-source.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { quoteWithoutSource } from "../quote-without-source.ts";
+
+export const detector: Detector = quoteWithoutSource;

package/src/detectors/registry/vague-deadline.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { vagueDeadline } from "../vague-deadline.ts";
+
+export const detector: Detector = vagueDeadline;

package/src/detectors/registry/version-mismatch.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { versionMismatch } from "../version-mismatch.ts";
+
+export const detector: Detector = versionMismatch;

package/src/detectors/relative-dates.ts

@@ -4,6 +4,7 @@ import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import type { DurationUnit } from "../derived/date-arithmetic.ts";
 import { relativeMismatches, type DatedValue, type Relative } from "../derived/relative-dates.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { dayWordFindings } from "./relative-day-words.ts";
 
 /** 期間の単位の語彙表。relative-year-unit は、向きの語が付くときだけ期間になる単位（「1年前」の年）。 */
 const DURATION_LEXICONS: readonly (readonly [string, DurationUnit])[] = [
@@ -96,7 +97,7 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
     relatives: relativesOf(doc, amounts),
     links: patternsOf(doc, "relative-link"),
   };
-  return relativeMismatches(input).map((mismatch) => ({
+  const counted = relativeMismatches(input).map((mismatch): Finding => ({
     rule: "relative-date-mismatch",
     severity: "warning",
     line: 0,
@@ -110,4 +111,5 @@ export const relativeDateMismatch: Detector = (doc): Finding[] => {
       offset: mismatch.target.start,
     },
   }));
+  return [...counted, ...dayWordFindings(doc, dates)];
 };

package/src/detectors/relative-day-words.ts

@@ -0,0 +1,126 @@
+// relative-date-mismatch, the day words: 「来週月曜（10月12日）」「明日（10月7日）」"next Monday (October 12)" against the
+// date field of an email or minutes. The words are the lexicons relative-week, relative-day, weekday and message-date-field;
+// the reckoning is derived/relative-weekdays.ts.
+import type { Finding, ProseDocument, Span } from "../plugin.ts";
+import type { DatedValue } from "../derived/relative-dates.ts";
+import { relativeDayMismatch, type DayWord } from "../derived/relative-weekdays.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const FULL = /^\d{4}-\d{2}-\d{2}$/u;
+const LATIN = /^[A-Za-z]/u;
+/** 文書の書き出し: 最初の見出しより前と、最初の見出しの節。メールや議事録の頭の日付（日付：、Date:）が書かれる所。 */
+const OPENING_SECTIONS = 1;
+/** The separators a date may follow its day word with: a space, a bracket, a comma (「来週月曜（10月12日）」). */
+const SEPARATORS = /[\s,、，(（:：]/gu;
+
+const wordPattern = (word: string): RegExp => new RegExp(LATIN.test(word) ? `\\b${escapeRegExp(word)}\\b` : escapeRegExp(word), "giu");
+
+const spansOf = (source: string, word: string): Span[] =>
+  [...source.matchAll(wordPattern(word))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** The weekday written right after a week word (Sunday is 0), and where it ends: the name, or the name without its last 日 (月曜). */
+const weekdayAt = (source: string, at: number, names: readonly string[]): { readonly weekday: number; readonly end: number } | undefined => {
+  const gap = source.slice(at).length - source.slice(at).trimStart().length;
+  const rest = source.slice(at + gap).toLowerCase();
+  const found = names
+    .map((name, weekday) => {
+      const lower = name.toLowerCase();
+      const short = LATIN.test(name) ? lower : lower.slice(0, -1);
+      const written = [lower, short].find((form) => form.length >= 2 && rest.startsWith(form));
+      return written === undefined ? undefined : { weekday, end: at + gap + written.length };
+    })
+    .find((entry) => entry !== undefined);
+  return gap > 1 ? undefined : found;
+};
+
+const dayWordsOf = (doc: ProseDocument): DayWord[] => {
+  const names = (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern);
+  const weeks = (doc.lexicons["relative-week"] ?? []).flatMap((entry): DayWord[] =>
+    spansOf(doc.source, entry.pattern).flatMap((span) => {
+      const day = weekdayAt(doc.source, span.end, names);
+      return day === undefined ? [] : [{ start: span.start, end: day.end, kind: "weekday", weeks: Number(entry.group), weekday: day.weekday }];
+    }),
+  );
+  const days = (doc.lexicons["relative-day"] ?? []).flatMap((entry): DayWord[] =>
+    spansOf(doc.source, entry.pattern).map((span) => ({ ...span, kind: "day", days: Number(entry.group) })),
+  );
+  // 「再来週」の中の「来週」、「明後日」の中の「明日」は読まない: 長い語が覆う語を落とす。
+  const all = [...weeks, ...days];
+  return all.filter(
+    (word) => !all.some((other) => other !== word && other.start <= word.start && word.end <= other.end && other.end - other.start > word.end - word.start),
+  );
+};
+
+/** The date written right after the day word: only separators and a link word (の, on) between. */
+const targetOf = (doc: ProseDocument, dates: readonly DatedValue[], word: DayWord): DatedValue | undefined => {
+  const next = dates.find((date) => date.start >= word.end);
+  if (next === undefined) return undefined;
+  const between = doc.source.slice(word.end, next.start).replace(SEPARATORS, "").toLowerCase();
+  const links = (doc.lexicons["relative-link"] ?? []).map((entry) => entry.pattern.replace(SEPARATORS, "").toLowerCase());
+  return between === "" || links.includes(between) ? next : undefined;
+};
+
+const lineStartAt = (source: string, offset: number): number => source.lastIndexOf("\n", offset - 1) + 1;
+
+const lineAt = (source: string, offset: number): string => {
+  const start = lineStartAt(source, offset);
+  const end = source.indexOf("\n", offset);
+  return source.slice(start, end === -1 ? source.length : end);
+};
+
+const FIELD_MARK = /^\s*(?:[-*+]\s+)?(?<label>[^:：]{1,12})[:：]/u;
+
+/**
+ * The date the day words count from: the first full date on a date field of the opening (「日付:」「日時:」"Date:", lexicon
+ * message-date-field), before the first heading or in the first heading's section. A document without one (a press release
+ * whose only date is an update stamp) has no date to count from.
+ */
+const baseOf = (doc: ProseDocument, dates: readonly DatedValue[], starts: readonly number[]): DatedValue | undefined => {
+  const labels = (doc.lexicons["message-date-field"] ?? []).map((entry) => entry.pattern.toLowerCase());
+  return dates.find((date) => {
+    const label = FIELD_MARK.exec(lineAt(doc.source, date.start))?.groups?.["label"]?.trim().toLowerCase() ?? "";
+    return FULL.test(date.value) && labels.includes(label) && starts.filter((start) => start <= date.start).length <= OPENING_SECTIONS;
+  });
+};
+
+const QUOTED_LINE = /^\s*>/u;
+
+/**
+ * Day words the document's date does not count: in a quoted reply (「> 明日（10月2日）」 counts from the quoted mail's date),
+ * or in a section whose heading names a date (「## 10月1日の会」: its 「本日」 is that day).
+ */
+const countedFromBase = (doc: ProseDocument, word: DayWord, datedHeadings: readonly number[], starts: readonly number[]): boolean => {
+  const section = starts.filter((start) => start <= word.start).at(-1);
+  return !QUOTED_LINE.test(lineAt(doc.source, word.start)) && (section === undefined || !datedHeadings.includes(section));
+};
+
+export const dayWordFindings = (doc: ProseDocument, dates: readonly DatedValue[]): Finding[] => {
+  const starts = doc.sections.filter((section) => section.depth > 0).map((section) => section.span.start);
+  const base = baseOf(doc, dates, starts);
+  if (base === undefined) return [];
+  const datedHeadings = starts.filter((start) => dates.some((date) => date.start >= start && date.start < start + lineAt(doc.source, start).length));
+  return dayWordsOf(doc)
+    .filter((word) => countedFromBase(doc, word, datedHeadings, starts))
+    .flatMap((word): Finding[] => {
+      const target = targetOf(doc, dates, word);
+      const expected = target === undefined || target === base ? undefined : relativeDayMismatch(base.value, word, target.value);
+      if (target === undefined || expected === undefined) return [];
+      return [
+        {
+          rule: "relative-date-mismatch",
+          severity: "warning",
+          line: 0,
+          column: 0,
+          quote: quoteAt(doc.source, target.start),
+          values: {
+            base: doc.source.slice(base.start, base.end),
+            relative: doc.source.slice(word.start, word.end),
+            target: doc.source.slice(target.start, target.end),
+            expected,
+            offset: target.start,
+          },
+        },
+      ];
+    });
+};

package/src/detectors/run-in-label.ts

@@ -0,0 +1,60 @@
+import type { Span } from "../plugin.ts";
+
+/** 行の頭の引用の印と字下げ、箇条の印、チェックボックス。この後ろで太字が開く。 */
+const QUOTE_INDENT = /^(?:[ \t]*>)*[ \t]*/u;
+const ITEM_MARKER = /^(?:[-*+]|\d{1,9}[.)])[ \t]+/u;
+const TASK_BOX = /^\[[ xX]\][ \t]+/u;
+const BOLD = /^(?:\*\*|__)$/u;
+
+type Opening = { readonly marker: string; readonly item: boolean };
+
+/** 行の頭から文の始まりまで（before）が、印の後ろで開いた太字だけか。 */
+const openingOf = (before: string): Opening | undefined => {
+  const unquoted = before.replace(QUOTE_INDENT, "");
+  const rest = unquoted.replace(ITEM_MARKER, "").replace(TASK_BOX, "");
+  return BOLD.test(rest) ? { marker: rest, item: rest.length < unquoted.length } : undefined;
+};
+
+/** 段落の切れ目になる前の行: 空の行（引用の中の空の行も）と見出し。 */
+const BLOCK_BEFORE = /^(?:[ \t]*>)*[ \t]*(?:#.*)?$/u;
+
+/** 文の終わりの句読点。札の句点を太字の外に書く形（**速く書ける**。）もある。 */
+const STOP = /[。．.！？!?]$/u;
+
+const lineAround = (source: string, offset: number): { readonly start: number; readonly end: number } => {
+  const end = source.indexOf("\n", offset);
+  return { start: source.lastIndexOf("\n", offset - 1) + 1, end: end === -1 ? source.length : end };
+};
+
+/** 太字が閉じる位置。文の直後か、文末の句読点の直前。 */
+const closingOf = (source: string, span: Span, marker: string): number | undefined => {
+  if (source.startsWith(marker, span.end)) return span.end;
+  const stop = STOP.exec(source.slice(span.start, span.end))?.[0];
+  const before = stop === undefined ? -1 : span.end - stop.length - marker.length;
+  return before > span.start && source.startsWith(marker, before) ? before : undefined;
+};
+
+/** 文全体を一つの太字が包むなら、太字と文の後ろの位置。途中で閉じる太字（**a** と **b。**）は包んでいない。 */
+const closedAt = (source: string, span: Span, marker: string): number | undefined => {
+  const closing = closingOf(source, span, marker);
+  if (closing === undefined || source.slice(span.start, closing).includes(marker)) return undefined;
+  return Math.max(closing + marker.length, span.end);
+};
+
+/** 行の頭が段落の頭か。箇条の印のある行は項目の頭。折り返した段落の続きの行（前の行に文がある）は頭ではない。 */
+const opensBlock = (source: string, lineStart: number, item: boolean): boolean => {
+  if (item || lineStart === 0) return true;
+  return BLOCK_BEFORE.test(source.slice(source.lastIndexOf("\n", lineStart - 2) + 1, lineStart - 1));
+};
+
+/**
+ * 行の頭の太字だけでできた文で、同じ行に続きがあるもの（「- **速く書ける。** 細かな文法を覚えなくても書けます。」の「速く書ける。」）。
+ * 項目や段落の札で、見出しと同じく本文の文ではない。太字だけの行（「**注意してください。**」）は札ではなく文。
+ */
+export const isRunInLabel = (source: string, span: Span): boolean => {
+  const line = lineAround(source, span.start);
+  const opening = openingOf(source.slice(line.start, span.start));
+  if (opening === undefined || !opensBlock(source, line.start, opening.item)) return false;
+  const after = closedAt(source, span, opening.marker);
+  return after !== undefined && after <= line.end && /\S/u.test(source.slice(after, line.end));
+};

package/src/detectors/sentence-counts.ts

@@ -73,12 +73,20 @@ export const sentenceConjunctiveCount: Detector = (doc, options): Finding[] => {
 
 type Opened = { readonly sentence: Sentence; readonly opener: string | undefined };
 
-const openerOf = (sentence: Sentence, lexicon: Lexicon): string | undefined => lexicon.find((entry) => entryOpens(sentence, entry))?.pattern;
+/**
+ * The lexicon's word the sentence opens with, unless it opens with one of `notOpeners`: "This Agreement" and "This section"
+ * point at the document itself, not back at the sentence before.
+ */
+const openerOf = (sentence: Sentence, lexicon: Lexicon, notOpeners: Lexicon): string | undefined =>
+  notOpeners.some((entry) => entryOpens(sentence, entry)) ? undefined : lexicon.find((entry) => entryOpens(sentence, entry))?.pattern;
+
+/** The phrases that open a sentence with a lexicon word but do not point back (this-document references). */
+export const NOT_OPENER_LEXICON = "demonstrative-not-opener";
 
 /** Runs of consecutive sentences in one paragraph that each open with a lexicon word. */
-export const openerRuns = (sentences: readonly Sentence[], lexicon: Lexicon): Opened[][] =>
+export const openerRuns = (sentences: readonly Sentence[], lexicon: Lexicon, notOpeners: Lexicon = []): Opened[][] =>
   sentences
-    .map((sentence) => ({ sentence, opener: openerOf(sentence, lexicon) }))
+    .map((sentence) => ({ sentence, opener: openerOf(sentence, lexicon, notOpeners) }))
     .reduce<Opened[][]>(
       (runs, opened) => {
         if (opened.opener === undefined) return [...runs, []];
@@ -104,8 +112,9 @@ const runFinding = (run: readonly Opened[], options: DetectorOptions): Finding =
 /** More than limit sentences in a row within one paragraph, each opening with a word from the lexicon (これ, その). */
 export const openerRun: Detector = (doc, options): Finding[] => {
   const lexicon = options.lexicon ?? [];
+  const notOpeners = doc.lexicons[NOT_OPENER_LEXICON] ?? [];
   return doc.paragraphs.flatMap((paragraph) =>
-    openerRuns(paragraph.sentences, lexicon)
+    openerRuns(paragraph.sentences, lexicon, notOpeners)
       .filter((run) => run.length > options.limit)
       .map((run) => runFinding(run, options)),
   );

package/src/detectors/sentence-ending.ts

@@ -1,6 +1,7 @@
 import { endingTokens, isClosed } from "../sentence-shape.ts";
 import { enumeratedRuns, enumeratorStarts, numberedStarts } from "./enumerated-runs.ts";
 import { continuesInto, groupOf, registerOf, slipsOf, type Register } from "./register.ts";
+import { isRunInLabel } from "./run-in-label.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -8,7 +9,7 @@ import type { Detector, Finding, LexiconEntry, ProseDocument, Sentence, Span } f
  *
  * どちらが正しいかは決めない。決めると、方針の違う書き手にそのまま無視される。
  * 見るのは文書の中での一貫性だけで、少数派のほうを指摘する。spec §12.3 の方針を日本語にも。
- * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）は文として数えない。
+ * 終止符で終わらないもの（見出しの下の `MaaSサービス` のような名前だけの行）と、項目や段落の頭の太字の札（**速く書ける。**）は文として数えない。
  */
 type Entry = { readonly sentence: Sentence; readonly register: Register; readonly group: number | undefined };
 
@@ -35,7 +36,7 @@ export const judgedSentences = (doc: ProseDocument, polite: readonly LexiconEntr
   const neutral = doc.lexicons["neutral-ending"] ?? [];
   const lists = doc.lists.map((list) => list.span);
   const found = doc.sentences.flatMap((sentence, index): { sentence: Sentence; register: Register }[] => {
-    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1])) return [];
+    if (!isClosed(sentence) || continuesInto(sentence, doc.sentences[index + 1]) || isRunInLabel(doc.source, sentence.span)) return [];
     const register = registerOfSentence(sentence, polite, neutral);
     return register === undefined ? [] : [{ sentence, register }];
   });