chaffjs 0.24.0 → 0.26.0

package/src/detectors/orthographic-variant.ts

@@ -4,6 +4,7 @@ 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";
 
 /** 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 +23,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 }];
@@ -140,11 +181,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/connective-hierarchy.ts

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

package/src/detectors/registry/missing-final-period.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { missingFinalPeriod } from "../missing-final-period.ts";
+
+export const detector: Detector = missingFinalPeriod;

package/src/detectors/registry/missing-space-after-comma.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { missingSpaceAfterComma } from "../missing-space-after-comma.ts";
+
+export const detector: Detector = missingSpaceAfterComma;

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/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 }];
   });

package/src/detectors/structure-tree.ts

@@ -4,6 +4,7 @@ import { numberingBreaks } from "../structure/numbering.ts";
 import { weekdayMismatches } from "../structure/weekday.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
+import { proseTotalMismatches } from "../structure/prose-total.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -104,15 +105,35 @@ const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
     node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
   );
 
-/** 合計の行が、上の金額の和と合わない。合計の語は言語パッケージの語彙表（total-label）から取る。 */
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
+const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
+  const amounts = amountsOf(tree);
+  const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
+  const words = {
+    totals: patternsOf(doc, "total-phrase"),
+    breakdowns: patternsOf(doc, "breakdown-phrase"),
+    discounts: patternsOf(doc, "discount-word"),
+    joiners: patternsOf(doc, "breakdown-gap-joiner"),
+  };
+  const prose = proseTotalMismatches(
+    doc.source,
+    doc.sentences.map((sentence) => sentence.span),
+    amounts,
+    words,
+  );
+  return [...lines, ...prose.filter((issue) => !lines.some((line) => line.offset === issue.offset))];
+};
+
+/**
+ * 合計が内訳の和と合わない。表と箇条書きの合計の行（合計の語は total-label）と、文の中の合計（total-phrase、breakdown-phrase）。
+ * 語は言語パッケージの語彙表から取る。
+ */
 export const totalMismatch: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : totalMismatches(
-        doc.source,
-        amountsOf(doc.structure),
-        (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
-      ).map((issue) => ({
+    : totalIssues(doc, doc.structure).map((issue) => ({
         rule: "total-mismatch",
         severity: "error",
         line: 0,
@@ -127,6 +148,7 @@ const rangeWordsOf = (doc: ProseDocument): RangeWords => ({
   closers: (doc.lexicons["range-closer"] ?? []).map((entry) => entry.pattern),
   frames: (doc.lexicons["range-frame"] ?? []).flatMap((entry) => rangeFrameOf(entry.pattern) ?? []),
   changes: (doc.lexicons["date-change-word"] ?? []).map((entry) => entry.pattern),
+  weekdays: (doc.lexicons["weekday"] ?? []).map((entry) => entry.pattern),
 });
 
 /** 期間の終わりが始まりより前。範囲の記号と語は言語パッケージの語彙表（range-connector、range-opener、range-closer）から取る。 */

package/src/detectors/unbalanced-bracket.ts

@@ -108,25 +108,40 @@ export const bracketProblems = (text: string): BracketProblem[] => {
   return [...scan.problems, ...scan.open.map(unclosedOf)].toSorted((left, right) => left.offset - right.offset);
 };
 
-/** sorted（昇順・重ならない）のどれかが offset を含むか。何万もの字の節があっても、URL ごとに全部をなめない。 */
-const coversOffset = (sorted: readonly Span[], offset: number): boolean => {
-  const span = sorted[firstEndingAfter(sorted, offset)];
-  return span !== undefined && span.start <= offset;
+/** sorted（昇順・接しもしない）で、offset の後ろの最初の境目: offset を含む範囲の終わりか、次の範囲の始まり。 */
+const borderAfter = (sorted: readonly Span[], offset: number): number => {
+  const next = sorted[firstEndingAfter(sorted, offset)];
+  if (next === undefined) return Number.POSITIVE_INFINITY;
+  return next.start <= offset ? next.end : next.start;
 };
 
+/** 覆いの中で URL そのものが終わる位置。ASCII でない字か、コードと字のまま見える範囲の境目（「`https://…`）」の「`」）で終わる。 */
+const urlProperEnd = (written: string, start: number, readable: readonly Span[]): number => {
+  const nonAscii = written.search(/[^\p{ASCII}]/u);
+  return Math.min(nonAscii === -1 ? written.length : nonAscii, borderAfter(readable, start) - start, written.length);
+};
+
+/** sorted（昇順・重ならない）のうち range に重なるものを、range の中に切り詰めたもの。何万もの字の節があっても、URL ごとに全部をなめない。 */
+const clippedTo = (sorted: readonly Span[], range: Span): Span[] =>
+  sorted
+    .slice(firstEndingAfter(sorted, range.start), firstEndingAfter(sorted, range.end) + 1)
+    .filter((span) => span.start < range.end)
+    .map((span) => ({ start: Math.max(span.start, range.start), end: Math.min(span.end, range.end) }));
+
 /**
  * 本文（prose）では URL を覆うが、覆いは空白まで取るので、URL の直後に続けて書いた字（「（https://example.jp/）」の「）」）まで消える。
- * 読み手には見えている字なので、ASCII でない字から先を元に戻す。コードの中の URL（texts の外）は戻さない。
+ * 読み手には見えている字なので、URL が終わった後ろの、字のまま見える範囲（texts）を元に戻す。コードの中の URL の後ろも同じ。
  */
 export const withRunOnRestored = (prose: string, source: string, texts: readonly Span[]): string => {
-  const readable = mergeSpans(texts, false);
+  const readable = mergeSpans(texts, true);
   const parts: string[] = [];
   const cursor = { at: 0 };
   [...source.matchAll(BARE_URL)].forEach((match) => {
-    const tail = match[0].search(/[^\p{ASCII}]/u);
-    if (tail === -1 || !coversOffset(readable, match.index)) return;
-    parts.push(prose.slice(cursor.at, match.index + tail), source.slice(match.index + tail, match.index + match[0].length));
-    cursor.at = match.index + match[0].length;
+    const tail = { start: match.index + urlProperEnd(match[0], match.index, readable), end: match.index + match[0].length };
+    clippedTo(readable, tail).forEach((span) => {
+      parts.push(prose.slice(cursor.at, span.start), source.slice(span.start, span.end));
+      cursor.at = span.end;
+    });
   });
   parts.push(prose.slice(cursor.at));
   return parts.join("");