chaffjs 0.35.0 → 0.36.0

package/src/detectors/addressee-edge.ts

@@ -0,0 +1,16 @@
+import type { Token } from "../plugin.ts";
+
+/** 連なりの尻の、宛先に付く語。surface はその語、start は文書全体の座標でその語の始まり。 */
+export type AddresseeSuffix = { readonly surface: string; readonly start: number };
+
+/**
+ * 漢字の連なり run（文書全体の座標で end に終わる）の尻が、宛先の名前に付く語（志木市役所市政情報課宛ての「宛」、御中）なら、
+ * その語。その語は名前の後ろに付くもので、名前の一部ではない。語の切れ目で始まるときだけ（宛ての語の頭が「宛」）。
+ * 折り返しをまたぐ語（御\n中）は span が surface より長いので、end から字数を引かず、end の直前の字を覆う語の始まりを使う。
+ */
+export const trailingAddressee = (tokens: readonly Token[], end: number, run: string, suffixes: readonly string[]): AddresseeSuffix | undefined => {
+  const suffix = suffixes.find((word) => word !== "" && run.length > word.length && run.endsWith(word));
+  if (suffix === undefined) return undefined;
+  const token = tokens.find((candidate) => candidate.span.start < end && end <= candidate.span.end);
+  return token !== undefined && token.surface.startsWith(suffix) ? { surface: suffix, start: token.span.start } : undefined;
+};

package/src/detectors/announced-count.ts

@@ -13,6 +13,7 @@ const countWordsOf = (doc: ProseDocument): CountWords => ({
   frames: patternsOf(doc, "count-frame"),
   hedgesBefore: patternsOf(doc, "count-hedge", "before"),
   hedgesAfter: patternsOf(doc, "count-hedge", "after"),
+  titles: patternsOf(doc, "count-title"),
 });
 
 const memberGroup = (doc: ProseDocument, group: string): string[] =>

package/src/detectors/bare-comparative.ts

@@ -1,12 +1,15 @@
 import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { quotedIn } from "../quoted-span.ts";
 import { followsInlineCode } from "./code-before.ts";
+import { isNamedStep, plainStepKeys } from "./graded-step.ts";
 
 /**
  * 比べる相手の無い比較（より良い結果、さらに高速に、The new engine is faster.）。何より良いのか、何より速いのかが書かれていない。
  * 語は語彙表 comparative-baseline が言う。group marker は日本語の比べる副詞（より、さらに）、more は英語の比べる語、comparative は比べた形の語
  * （faster、better）、baseline は相手を言う語（従来、以前、than、previous）、exempt は比較でない決まった言い方（より多くの、より詳しく）、
  * condition は比較を条件や仮定の下に置く語（使うと、if、would）。条件を書いた比較は、その条件の無い場合と比べている。
+ * beyond は比べた形のすぐ前で、いま述べたものを越えると言う語（even better、still faster）。相手はその直前に書いてある。
+ * aim は比べた語の後ろで、今より良くする目当てを言う語（より良い社会、より良いものにする）。比べる相手は今の状態。
  * 同じ文か前の二文に相手を言う語があれば、相手は書いてある。
  */
 
@@ -17,6 +20,8 @@ export type ComparativeLists = {
   readonly baselines: readonly string[];
   readonly exempt: ReadonlySet<string>;
   readonly conditions: ReadonlySet<string>;
+  readonly beyond: ReadonlySet<string>;
+  readonly aims: ReadonlySet<string>;
 };
 
 export type BareComparative = { readonly first: Token; readonly last: Token };
@@ -44,13 +49,35 @@ const isGradable = (tokens: readonly Token[], at: number): boolean => {
 /** 比べる副詞が語の頭に立つか。前が助詞・記号・接続の語か文の頭のときだけ（「学年だより等」の「より」は語の一部）。 */
 const OPENS_WORD = new Set(["ADP", "PUNCT", "SCONJ", "CCONJ", "ADV"]);
 
-/** 日本語: 副詞の「より」「さらに」の直後の、程度を言える語。比較の決まった言い方（より多くの）は除く。 */
+/** 語から続く語をつないだもの（もの、ものに、ものにする）と、それぞれの後ろの語の位置。 */
+const MAX_AIM_TOKENS = 3;
+const runsFrom = (tokens: readonly Token[], at: number): { readonly run: string; readonly after: number }[] =>
+  tokens
+    .slice(at, at + MAX_AIM_TOKENS)
+    .reduce<{ run: string; after: number }[]>(
+      (runs, token, index) => [...runs, { run: `${runs.at(-1)?.run ?? ""}${token.surface}`, after: at + index + 1 }],
+      [],
+    );
+
+/** 続く語に名詞が付いて、より長い語の頭になっているか（社会保障の「社会」）。 */
+const headsCompound = (tokens: readonly Token[], after: number): boolean => {
+  const [last, next] = [tokens[after - 1], tokens[after]];
+  return last?.pos === "NOUN" && next?.pos === "NOUN" && last.span.end === next.span.start;
+};
+
+/** 程度を言う語（at）の後ろが、今より良くする目当てか（より良い社会、より豊かな暮らし、より良いものにする）。 */
+const namesAim = (tokens: readonly Token[], at: number, aims: ReadonlySet<string>): boolean => {
+  const next = tokens[at]?.pos === "NOUN" && ADJECTIVAL_TAIL.has(tokens[at + 1]?.surface ?? "") ? at + 2 : at + 1;
+  return runsFrom(tokens, next).some(({ run, after }) => aims.has(run) && !headsCompound(tokens, after));
+};
+
+/** 日本語: 副詞の「より」「さらに」の直後の、程度を言える語。比較の決まった言い方（より多くの）と、今より良くする目当て（より良い社会）は除く。 */
 const markedAt = (tokens: readonly Token[], at: number, lists: ComparativeLists): BareComparative | undefined => {
   const [marker, word] = [tokens[at], tokens[at + 1]];
   if (marker?.pos !== "ADV" || !lists.markers.has(marker.surface) || word === undefined || lists.exempt.has(word.surface)) return undefined;
   const previous = tokens[at - 1];
   if (previous !== undefined && !OPENS_WORD.has(previous.pos)) return undefined;
-  return isGradable(tokens, at + 1) ? { first: marker, last: word } : undefined;
+  return isGradable(tokens, at + 1) && !namesAim(tokens, at + 1, lists.aims) ? { first: marker, last: word } : undefined;
 };
 
 /** 比べた形の後ろで節が終わるか。読点の後ろに形容詞が続けば、名詞の前に並べた修飾語（better, more predictable results）。 */
@@ -87,10 +114,16 @@ const predicateAt = (tokens: readonly Token[], at: number, lists: ComparativeLis
 const isConditional = (tokens: readonly Token[], found: BareComparative, conditions: ReadonlySet<string>): boolean =>
   tokens.some((token) => token.span.start < found.first.span.start && token.pos !== "CCONJ" && conditions.has(lower(token)));
 
+/** 比べた形のすぐ前が、いま述べたものを越えると言う語か（performed even better）。 */
+const goesBeyond = (tokens: readonly Token[], found: BareComparative, beyond: ReadonlySet<string>): boolean => {
+  const before = tokens.findLastIndex((token) => token.span.end <= found.first.span.start);
+  return beyond.has(lower(tokens[before]));
+};
+
 export const bareComparativesIn = (tokens: readonly Token[], lists: ComparativeLists): BareComparative[] =>
   tokens
     .flatMap((_, at) => markedAt(tokens, at, lists) ?? predicateAt(tokens, at, lists) ?? [])
-    .filter((found) => !isConditional(tokens, found, lists.conditions));
+    .filter((found) => !isConditional(tokens, found, lists.conditions) && !goesBeyond(tokens, found, lists.beyond));
 
 /**
  * 語が比べる相手を言う語か。語の形か原形で照らし、一字の語（旧）は語の頭だけ（旧版は相手、復旧は相手でない）。
@@ -128,6 +161,8 @@ export const listsOf = (lexicon: Lexicon): ComparativeLists => ({
   baselines: groupOf(lexicon, "baseline"),
   exempt: new Set(groupOf(lexicon, "exempt")),
   conditions: new Set(groupOf(lexicon, "condition")),
+  beyond: new Set(groupOf(lexicon, "beyond")),
+  aims: new Set(groupOf(lexicon, "aim")),
 });
 
 /** 鉤括弧の中の比較（「給与所得の確定申告がさらに簡単に！」ページ）は題や語を挙げたもので、書き手の比較ではない。 */
@@ -139,12 +174,18 @@ const isThanAfterCode = (doc: ProseDocument, found: BareComparative): boolean =>
 
 export const bareComparative: Detector = (doc): Finding[] => {
   const lists = listsOf(doc.lexicons["comparative-baseline"] ?? []);
+  const steps = plainStepKeys(
+    doc.sentences.map((sentence) => ({ tokens: sentence.tokens ?? [], quoted: quotedIn(sentence) })),
+    lists.markers,
+    isGradable,
+  );
   return doc.sentences.flatMap((sentence, at) => {
     const nearby = doc.sentences.slice(Math.max(0, at - BASELINE_REACH), at + 1);
     if (sentence.embeddedLanguage !== undefined || nearby.some((near) => namesBaseline(near, lists.baselines))) return [];
     const quoted = quotedIn(sentence);
     return bareComparativesIn(sentence.tokens ?? [], lists)
       .filter((found) => !quoted.some((span) => insideSpan(found, span)) && !isThanAfterCode(doc, found))
+      .filter((found) => !lists.markers.has(found.first.surface) || !isNamedStep(sentence.tokens ?? [], found.last, steps))
       .map((found) => ({
         rule: "",
         severity: "info",

package/src/detectors/blank-structure.ts

@@ -8,6 +8,7 @@ import { quoteAt } from "./structure-tree.ts";
 import { amountColumnOf, isTotalRowGap, type BodyRow } from "../structure/total-row-blank.ts";
 import { isAmountNameLine, isTotalLine } from "../structure/total-line.ts";
 import { isTotalLabel, withoutLeadingBlankCells } from "../structure/total.ts";
+import { isSpannedLabelGap } from "../structure/spanned-label-blank.ts";
 
 /** Fewer body rows than this, and one blank is as likely a choice as a gap. */
 const MIN_BODY_ROWS = 3;
@@ -67,8 +68,6 @@ const cellOffset = (cell: MarkdownNode | undefined, row: MarkdownNode | undefine
 /** Whether a row is a total, subtotal or tax row, judged from the row's source text. */
 export type IsTotalRow = (rowText: string) => boolean;
 
-const NO_TOTAL_ROWS: IsTotalRow = () => false;
-
 const rowSource = (source: string, row: MarkdownNode): string => {
   const span = spanOf(row);
   return span === undefined ? "" : source.slice(span.start, span.end);
@@ -79,30 +78,40 @@ const bodyRowOf = (source: string, row: MarkdownNode, isTotalRow: IsTotalRow): B
   cells: (row.children ?? []).map((cell) => (shows(cell) ? sourceOf(source, cell) : undefined)),
 });
 
+/** How a table's rows are read: which rows are totals, and the total words that make a cell a row label (Total score). */
+type TableReading = { readonly isTotalRow: IsTotalRow; readonly totalWords: readonly string[] };
+
+const NO_TOTALS: TableReading = { isTotalRow: () => false, totalWords: [] };
+
 /**
  * The one blank body cell of a column whose other body rows are all filled, unless it is a total row's blank beside its
- * amount. Such a blank still counts as a second blank, so the rows it shares a column with stay as unreported as before.
+ * amount, or the second column of a label that spans two (| Total score |  | 5 |). Such a blank still counts as a second
+ * blank, so the rows it shares a column with stay as unreported as before.
  */
-const columnBlank = (source: string, header: MarkdownNode, body: readonly MarkdownNode[], rows: readonly BodyRow[], column: number): Blank[] => {
+const columnBlank = (source: string, table: TableRows, totalWords: readonly string[], column: number): Blank[] => {
+  const { header, body, rows } = table;
   const blanks = rows.flatMap((row, index) => (row.cells[column] === undefined ? [index] : []));
   const at = blanks[0];
   const row = at === undefined ? undefined : rows[at];
   if (blanks.length !== 1 || at === undefined || row === undefined) return [];
   if (isTotalRowGap(row, column, amountColumnOf(rows, header.children?.length ?? 0))) return [];
+  if (isSpannedLabelGap(row.cells, column, totalWords)) return [];
   const offset = cellOffset(body[at]?.children?.[column], body[at]);
   const name = sourceOf(source, header.children?.[column]);
   return offset === undefined || name === "" ? [] : [{ offset, name }];
 };
 
+type TableRows = { readonly header: MarkdownNode; readonly body: readonly MarkdownNode[]; readonly rows: readonly BodyRow[] };
+
 /** The first column is skipped: a blank there often means "same as above". */
-const tableBlanksOf = (source: string, table: MarkdownNode, isTotalRow: IsTotalRow): Blank[] => {
+const tableBlanksOf = (source: string, table: MarkdownNode, reading: TableReading): Blank[] => {
   const [header, ...body] = table.children ?? [];
   if (header === undefined || body.length < MIN_BODY_ROWS) return [];
-  const rows = body.map((row) => bodyRowOf(source, row, isTotalRow));
+  const rows = body.map((row) => bodyRowOf(source, row, reading.isTotalRow));
   const columns = header.children?.length ?? 0;
   return Array.from({ length: columns }, (_unused, column) => column)
     .slice(1)
-    .flatMap((column) => columnBlank(source, header, body, rows, column));
+    .flatMap((column) => columnBlank(source, { header, body, rows }, reading.totalWords, column));
 };
 
 /** Quoted material is someone else's: email replies the document model found, and every Markdown blockquote. */
@@ -118,8 +127,8 @@ const blocksOutsideQuotes = (source: string, type: string, replies: readonly Spa
 };
 
 /** Blank cells in every table outside quotes. */
-export const tableBlanks = (source: string, replies: readonly Span[] = [], isTotalRow: IsTotalRow = NO_TOTAL_ROWS): Blank[] =>
-  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table, isTotalRow));
+export const tableBlanks = (source: string, replies: readonly Span[] = [], reading: TableReading = NO_TOTALS): Blank[] =>
+  blocksOutsideQuotes(source, "table", replies).flatMap((table) => tableBlanksOf(source, table, reading));
 
 type Item = { readonly node: MarkdownNode; readonly text: string | undefined; readonly empty: boolean };
 
@@ -192,5 +201,7 @@ const totalRowOf = (doc: ProseDocument): IsTotalRow => {
   return (rowText) => isTotalLine(rowText, totals) || isAmountNameLine(rowText, totals) || isTotalLabel(withoutLeadingBlankCells(rowText), taxes);
 };
 
-export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) => tableBlanks(doc.source, doc.replyQuotes ?? [], totalRowOf(doc)));
+export const emptyTableCell: Detector = findingsOf("empty-table-cell", (doc) =>
+  tableBlanks(doc.source, doc.replyQuotes ?? [], { isTotalRow: totalRowOf(doc), totalWords: patternsOf(doc, "total-label") }),
+);
 export const emptyListItem: Detector = findingsOf("empty-list-item", (doc) => listBlanks(doc.source, doc.replyQuotes ?? []));

package/src/detectors/bracket-specified.ts

@@ -0,0 +1,25 @@
+import { asideAt } from "./open-end-names.ts";
+
+// A vague word pinned down by the bracket right after it: 一定の事項（インボイスに記載が必要な事項）, a reasonable fee (USD 50).
+// The aside says what the word leaves open, so the word is not vague there. An aside that only gives the phrase a name
+// (以下「措置」という, hereinafter the "Fee") pins nothing down. Pure: the words that start a name come in.
+
+/** What may stand between the vague word and the bracket: the noun it qualifies (事項, fee), no punctuation. */
+const BEFORE_BRACKET = /^[\p{L}\p{N}\p{M} ]{0,12}?(?=[（(])/u;
+
+const startsWithName = (aside: string, nameMarkers: readonly string[]): boolean => {
+  const lower = aside.trimStart().toLowerCase();
+  return nameMarkers.some((marker) => marker !== "" && lower.startsWith(marker.toLowerCase()));
+};
+
+/**
+ * Whether the words right after end (an offset in text) are pinned down by a bracket: at most a short noun, then an
+ * aside that opens and closes and holds more than a name. nameMarkers: the words that start a name (以下, hereinafter).
+ */
+export const specifiedByBracket = (text: string, end: number, nameMarkers: readonly string[]): boolean => {
+  const rest = text.slice(end);
+  const before = BEFORE_BRACKET.exec(rest);
+  if (before === null) return false;
+  const aside = asideAt(text, end + before[0].length);
+  return aside !== undefined && aside.trim() !== "" && !startsWithName(aside, nameMarkers);
+};

package/src/detectors/broken-link.ts

@@ -62,12 +62,36 @@ const CITATION_NUMBERS = /^[\d\s,，、–-]+$/u;
 /** 画像の参照（`![alt][label]`）の頭の印。指摘の範囲に含める。 */
 const IMAGE_MARK = "!";
 
+/** 印の前の逃がし（\）を数えるのに見る字数。 */
+const ESCAPE_REACH = 16;
+const BACKSLASH = "\\";
+
+/** 字の並びの終わりに続く \ の数。 */
+const trailingBackslashes = (text: string): number => {
+  const reversed = [...text].reverse();
+  const other = reversed.findIndex((char) => char !== BACKSLASH);
+  return other === -1 ? reversed.length : other;
+};
+
+/** start の括弧の直前に、逃がしていない ! がある（「\![x][]」は画像ではなくリンク）。 */
+const imageAt = (source: string, start: number): boolean => {
+  if (source.charAt(start - 1) !== IMAGE_MARK) return false;
+  return trailingBackslashes(source.slice(Math.max(0, start - 1 - ESCAPE_REACH), start - 1)) % 2 === 0;
+};
+
+/**
+ * 名前を省いた画像の参照（`![Complete][]`）は、サイトが全ページに定義を足す印や絵（mdBook の前処理、サイト共通の定義）。
+ * 画像の行き先をページの中で一度も書かずに名前だけで呼ぶのは、定義がページの外にあるとき。名前を書いた形（`![alt][logo]`）と
+ * リンク（`[text][]`）は指摘する。
+ */
+export const siteDefinedImage = (source: string, start: number, label: string): boolean => label === "" && imageAt(source, start);
+
 export const unresolvedReferences = (source: string, markup: Markup): Span[] =>
   markup.texts.flatMap((text) =>
     [...source.slice(text.start, text.end).matchAll(REFERENCE_LIKE)]
-      .filter((match) => !CITATION_NUMBERS.test(match[1] ?? ""))
+      .filter((match) => !CITATION_NUMBERS.test(match[1] ?? "") && !siteDefinedImage(source, text.start + match.index, match[2] ?? ""))
       .map((match) => ({ start: text.start + match.index, end: text.start + match.index + match[0].length }))
-      .map((span) => (source.charAt(span.start - 1) === IMAGE_MARK ? { start: span.start - 1, end: span.end } : span)),
+      .map((span) => (imageAt(source, span.start) ? { start: span.start - 1, end: span.end } : span)),
   );
 
 const emptyLinks = (doc: ProseDocument, markup: Markup): Finding[] =>

package/src/detectors/caps-caption.ts

@@ -4,6 +4,8 @@
  * captions this way by convention, and prose that names one ("the FOR FURTHER INFORMATION CONTACT section") repeats it.
  * A line of a hard-wrapped paragraph in capitals (a disclaimer) has text above it, so it is no caption.
  */
+import { linesOf, type Line } from "../structure/lines.ts";
+import type { Span } from "../plugin.ts";
 
 /** Markdown heading or list marks and spaces that may stand before a caption on its line. */
 const LINE_LEAD = /^[ \t]*(?:#{1,6}[ \t]+|[-*+][ \t]+)?$/u;
@@ -59,3 +61,43 @@ export const captionsOf = (source: string): ReadonlySet<string> => {
     }),
   );
 };
+
+/** A line ends a sentence when its last mark, past closing quotes and brackets, is a period, a question or an exclamation mark. */
+const SENTENCE_END = /[.!?]["'”’)\]]*[ \t\r]*$/u;
+const UPPER = /[A-Z]/u;
+const LOWER = /[a-z]/u;
+
+const isCapitalLine = (line: Line): boolean => {
+  const bare = line.text.replace(LEAD, "");
+  return UPPER.test(bare) && !LOWER.test(bare);
+};
+
+/** The lines in paragraphs: runs of lines between blank lines. */
+const paragraphsOf = (lines: readonly Line[]): Line[][] =>
+  lines.reduce<Line[][]>((paragraphs, line, index) => {
+    if (BLANK_LINE.test(line.text)) return paragraphs;
+    const above = lines[index - 1];
+    if (above !== undefined && !BLANK_LINE.test(above.text)) paragraphs.at(-1)?.push(line);
+    else paragraphs.push([line]);
+    return paragraphs;
+  }, []);
+
+const spanOf = (paragraph: readonly Line[]): Span[] => {
+  const first = paragraph[0];
+  const last = paragraph.at(-1);
+  return first === undefined || last === undefined ? [] : [{ start: first.start, end: last.start + last.text.length }];
+};
+
+/**
+ * The paragraphs in capitals at the head of a document, before its first sentence: a letterhead, an office's name, an
+ * address block (BOARD OF GOVERNORS / WASHINGTON, D.C. 20551). Every line is in capitals and none ends a sentence, so a
+ * disclaimer in capitals, which is sentences, is not one. A document with no sentence has no head to tell apart.
+ */
+export const letterheadSpans = (source: string): Span[] => {
+  const paragraphs = paragraphsOf(linesOf(source));
+  const firstSentence = paragraphs.findIndex((paragraph) => paragraph.some((line) => SENTENCE_END.test(line.text)));
+  return paragraphs
+    .slice(0, Math.max(firstSentence, 0))
+    .filter((paragraph) => paragraph.every(isCapitalLine))
+    .flatMap(spanOf);
+};

package/src/detectors/caps-phrase.ts

@@ -0,0 +1,17 @@
+// Phrases set in capitals by convention ("NOW, THEREFORE, BE IT RESOLVED" in a resolution). Pure.
+import { escapeRegExp } from "../orthography.ts";
+
+const COMMA_OR_SPACE = /,?\s+/u;
+
+const wordsOf = (text: string): string => text.trim().split(COMMA_OR_SPACE).join(" ");
+
+/**
+ * Whether a run of capitals is made only of the listed phrases of several words, one after another ("NOW, THEREFORE" then
+ * "BE IT RESOLVED"). A comma after a word, as a run of capitals writes it, is ignored. One-word entries (MUST) match nothing here.
+ */
+export const isConventionalPhrase = (run: string, entries: Iterable<string>): boolean => {
+  const phrases = [...entries].map(wordsOf).filter((phrase) => phrase.includes(" "));
+  if (phrases.length === 0) return false;
+  const one = `(?:${phrases.map(escapeRegExp).join("|")})`;
+  return new RegExp(`^${one}(?: ${one})*$`, "u").test(wordsOf(run));
+};

package/src/detectors/char-shape.ts

@@ -1,6 +1,7 @@
 import type { Detector, DocumentProfile, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 import { compacted } from "./gram-place.ts";
 import { leadingCounter, trailingPrefix } from "./counter-edge.ts";
+import { trailingAddressee } from "./addressee-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
@@ -54,7 +55,15 @@ const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names:
 };
 
 /** 連なりを数えないと決める語彙: 住所の先頭にしか来ない単位（都道府県）と、組織の名前の形と単位と、題の名前を閉じる語。 */
-type NameWords = { readonly topUnits: ReadonlySet<string>; readonly organisation: OrganisationWords; readonly title: TitleWords };
+type NameWords = {
+  readonly topUnits: ReadonlySet<string>;
+  readonly organisation: OrganisationWords;
+  readonly title: TitleWords;
+  /** 数の後ろで日付・時刻の位置を言う単位（月）。連なりの頭にあれば、数に付いた助数詞。 */
+  readonly positional: readonly string[];
+  /** 宛先の名前に付く語（宛、御中）。連なりの尻にあれば、名前の後ろに付いた語。 */
+  readonly addressee: readonly string[];
+};
 
 /** 1 つの文書で連なりを読むのに要るもの。titled は、文書の中で題として置かれた名前（titledNames）。 */
 type RunContext = {
@@ -85,16 +94,19 @@ const isTitle = (tokens: readonly Token[], span: Span, text: string, placed: boo
   (placed || isTitledName(text, context.titled));
 
 /**
- * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）と、尻の、数に付く接頭の語（施行令第172条の「第」）は数えない。
+ * 数えない連なりは空。頭の、数に付いた助数詞（2日日本弁護士連合会の「日」）と、尻の、数に付く接頭の語（施行令第172条の「第」）と
+ * 宛先に付く語（市政情報課宛ての「宛」）は数えない。
  * 住所か名前かは、それを外した残りで決める（1日日本銀行の「日本銀行」）。品詞が無ければ判定しない。
  */
 const measuredRun = (tokens: readonly Token[] | undefined, run: KanjiRun, context: RunContext): string => {
   if (run.quoted) return "";
   if (tokens === undefined || run.span === undefined) return run.text;
-  const counter = leadingCounter(tokens, run.span.start, run.text);
+  const counter = leadingCounter(tokens, run.span.start, run.text, context.words.positional);
   const prefix = trailingPrefix(tokens, run.span.end, run.text);
-  const rest = { start: counter?.span.end ?? run.span.start, end: prefix?.span.start ?? run.span.end };
-  const text = run.text.slice(counter?.surface.length ?? 0, run.text.length - (prefix?.surface.length ?? 0));
+  const tail =
+    prefix === undefined ? trailingAddressee(tokens, run.span.end, run.text, context.words.addressee) : { surface: prefix.surface, start: prefix.span.start };
+  const rest = { start: counter?.span.end ?? run.span.start, end: tail?.start ?? run.span.end };
+  const text = run.text.slice(counter?.surface.length ?? 0, run.text.length - (tail?.surface.length ?? 0));
   return isPlaceName(tokens, rest, context.words) || isTitle(tokens, rest, text, run.placed, context) ? "" : text;
 };
 
@@ -120,8 +132,14 @@ export const kanjiRun: Detector = (doc, options): Finding[] => {
   const patterns = (id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
   const words: NameWords = {
     topUnits: new Set(patterns("prefecture-unit")),
-    organisation: { forms: patterns("organisation-form"), units: patterns("organisation-unit") },
+    organisation: {
+      forms: patterns("organisation-form"),
+      closingForms: (doc.lexicons["organisation-form"] ?? []).filter((entry) => entry.position !== "before").map((entry) => entry.pattern),
+      units: patterns("organisation-unit"),
+    },
     title: { endings: patterns("title-ending") },
+    positional: patterns("calendar-unit"),
+    addressee: patterns("addressee-suffix"),
   };
   const names = doc.names ?? [];
   const context: RunContext = { profile: doc.profile, names, words, titled: titledNames(doc, doc.profile, names) };
@@ -141,10 +159,12 @@ export const kanjiRun: Detector = (doc, options): Finding[] => {
 /**
  * 中黒で並べると、どこまでが 1 つの項目か分からなくなる。
  * 「企画・開発・運用・保守体制」は、保守体制が 1 つなのか保守と体制なのか読めない。
+ * 語彙表（nakaguro-word）の、中黒を含めて 1 語の語（キャッシュ・フロー）の中黒は並べていないので数えない。
  */
-export const middleDot: Detector = (doc, options): Finding[] =>
-  doc.sentences
-    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text) }))
+export const middleDot: Detector = (doc, options): Finding[] => {
+  const words = (options.lexicon ?? []).map((entry) => entry.pattern).toSorted((left, right) => right.length - left.length);
+  return doc.sentences
+    .map((sentence) => ({ sentence, count: parallelDotCount(sentence.text, words) }))
     .filter(({ count }) => count > options.limit)
     .map(({ sentence, count }) => ({
       rule: "no-nakaguro-parallel",
@@ -154,3 +174,4 @@ export const middleDot: Detector = (doc, options): Finding[] =>
       quote: sentence.text.trim(),
       values: { count, limit: options.limit, offset: sentence.span.start },
     }));
+};

package/src/detectors/cited-title.ts

@@ -71,13 +71,24 @@ const VENUE_END = /^\s*(?:[,;.]|$)/u;
  */
 const holdsPhrase = (runs: Runs, start: number, end: number): boolean => firstIn(runs.phrasePair, { start: start + 1, end: end + 1 }) !== -1;
 
+const LETTER = /\p{L}/u;
+
+/** 語の続きのすぐ前が、題名を導く語（whose full title is、entitled）で終わるか。語の途中（retitled）からは読まない。 */
+const afterTitleCue = (source: string, first: Token, titleCues: readonly string[]): boolean => {
+  const before = source.slice(source.lastIndexOf("\n", first.span.start - 1) + 1, first.span.start);
+  if (before === before.trimEnd()) return false;
+  const lead = before.trimEnd().toLowerCase();
+  return titleCues.some((cue) => cue !== "" && lead.endsWith(cue.toLowerCase()) && !LETTER.test(lead.charAt(lead.length - cue.length - 1)));
+};
+
 /**
  * 文の and / or が、引用した題名の中にあるか。and / or の両隣が Title Case の語の続きで、2 語以上の句を含み、その続きが
- * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）とき。
+ * 引用符か強調の印で囲まれているか、引用符で閉じた論文名のすぐ後ろにあって読点か文の終わりが続く（誌名）か、題名を導く語
+ * （titleCues: whose full title is、entitled）のすぐ後ろにあるとき。
  * 本文の固有名詞の並び（Login.gov, TTS Engineering and USAi）や著者の並びは囲まれていないので、題名と読まない。
  * 文を一度だけ読み、どの位置の問いにも続きを読み直さずに答える。
  */
-export const citedTitles = (tokens: readonly Token[], source: string): ((at: number) => boolean) => {
+export const citedTitles = (tokens: readonly Token[], source: string, titleCues: readonly string[] = []): ((at: number) => boolean) => {
   const runs = runsOf(tokens, source);
   return (at) => {
     const start = leftStart(runs, at);
@@ -88,7 +99,8 @@ export const citedTitles = (tokens: readonly Token[], source: string): ((at: num
     if (!holdsPhrase(runs, start, end)) return false;
     const before = source.slice(Math.max(0, first.span.start - MARK_REACH), first.span.start);
     const after = source.slice(last.span.end, last.span.end + MARK_REACH);
-    return (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+    const quoted = (OPENING.test(before) && CLOSING.test(after)) || (AFTER_QUOTED_TITLE.test(before) && VENUE_END.test(after));
+    return quoted || afterTitleCue(source, first, titleCues);
   };
 };
 

package/src/detectors/counter-edge.ts

@@ -16,15 +16,30 @@ const wordBefore = (tokens: readonly Token[], at: number): Token | undefined =>
   return beyond !== undefined && touches(beyond, previous) ? beyond : undefined;
 };
 
+const DIGITS = /^[0-9０-９]+$/u;
+
+/**
+ * 数と一語に解析された日付の単位（全角の「４月」）。連なりは単位から始まるので、単位の分だけの語にして返す。
+ * positional は数の後ろに置くだけで暦や時計の位置を言う単位（月、時）。
+ */
+const gluedUnit = (tokens: readonly Token[], start: number, run: string, positional: readonly string[]): Token | undefined => {
+  const token = tokens.find((candidate) => candidate.span.start < start && start < candidate.span.end);
+  if (token === undefined) return undefined;
+  const unit = positional.find((word) => token.surface.endsWith(word) && DIGITS.test(token.surface.slice(0, -word.length)));
+  return unit !== undefined && run.startsWith(unit) ? { ...token, surface: unit, span: { start, end: token.span.end } } : undefined;
+};
+
 /**
  * 漢字の連なり run（文書全体の座標で start から始まる）の頭が、直前の数に付いた助数詞（2日、第76回、24時間）なら、その助数詞の語。
  * 数字が区切りを見せるので、助数詞は数と読まれ、後ろの複合語の一部ではない。そうでなければ undefined。
+ * 解析が助数詞と言わない日付の単位（4月の「月」）も、positional にあれば助数詞と読む。
  * 折り返しをまたぐ語（年\n度）は span が surface より長いので、連なりの残りは span の終わりから始まる。
  */
-export const leadingCounter = (tokens: readonly Token[], start: number, run: string): Token | undefined => {
+export const leadingCounter = (tokens: readonly Token[], start: number, run: string, positional: readonly string[] = []): Token | undefined => {
   const at = tokens.findIndex((token) => token.span.start === start);
   const counter = tokens[at];
-  if (counter === undefined || !isCounter(counter) || !isNumber(wordBefore(tokens, at))) return undefined;
+  if (counter === undefined) return gluedUnit(tokens, start, run, positional);
+  if (!(isCounter(counter) || positional.includes(counter.surface)) || !isNumber(wordBefore(tokens, at))) return undefined;
   return run.startsWith(counter.surface) ? counter : undefined;
 };
 

package/src/detectors/date-any-year.ts

@@ -13,10 +13,11 @@ export const YEAR_SPAN_JOINER_LEXICON = "year-span-joiner";
  * `adjacent`: just before the date ("each December 31"). `near`: ending a few characters before it (決算日は、12月31日).
  * `label`: before the bracket the date is in (年末年始閉庁日（12月29日～1月3日）). `continues`: opening a list item just
  * after an example's item, it carries the example on ("- For example, … June 22." then "- If instead … June 25").
+ * `listed`: named in one list with the date, only list joiners between (祝休日及び12月29日, "public holidays and December 24").
  */
-export type MarkerReach = "sentence" | "example" | "adjacent" | "near" | "label" | "continues";
+export type MarkerReach = "sentence" | "example" | "adjacent" | "near" | "label" | "continues" | "listed";
 
-export const MARKER_REACHES: readonly MarkerReach[] = ["sentence", "example", "adjacent", "near", "label", "continues"];
+export const MARKER_REACHES: readonly MarkerReach[] = ["sentence", "example", "adjacent", "near", "label", "continues", "listed"];
 
 export type AnyYearMarker = { readonly word: string; readonly reach: MarkerReach };
 
@@ -151,8 +152,24 @@ const continuesExample = (date: DateSpan, before: string, source: string, marker
   return above !== undefined && exampleItem(source, above, lineStart(source, date.offset) - 1, markers, LIST_REACH);
 };
 
-const coversDate = (before: string, dateStart: string, intro: string | undefined, word: string, reach: MarkerReach): boolean => {
+/** What is left of `gap` once the list joiners at its head and the spaces around them are taken off. */
+const afterJoiners = (gap: string, joiners: readonly string[]): string => {
+  const trimmed = gap.trimStart();
+  const joiner = joiners.find((candidate) => candidate !== "" && trimmed.startsWith(candidate) && !runsOn(trimmed, candidate));
+  return joiner === undefined ? trimmed : afterJoiners(trimmed.slice(joiner.length), joiners);
+};
+
+/** The word stands just before the date with only list joiners between: 「祝休日及び」, "holidays, and ". */
+const listedBefore = (before: string, word: string, joiners: readonly string[]): boolean => {
+  const found = lastWordAt(before, word);
+  if (found === -1) return false;
+  const gap = before.slice(found + word.length);
+  return gap.trim() !== "" && afterJoiners(gap, joiners) === "";
+};
+
+const coversDate = (before: string, dateStart: string, intro: string | undefined, word: string, reach: MarkerReach, joiners: readonly string[]): boolean => {
   if (reach === "adjacent") return isAdjacent(latinLower(before), word);
+  if (reach === "listed") return listedBefore(latinLower(before), word, joiners);
   if (reach === "near") return lastWordAt(latinLower(before.slice(-(word.length + NEAR_REACH))), word) !== -1;
   if (reach === "label") return latinLower(labelOf(before) ?? "").includes(word);
   if (reach === "continues") return false;
@@ -160,11 +177,15 @@ const coversDate = (before: string, dateStart: string, intro: string | undefined
   return inItem || inSentence(before, dateStart, word) || (intro !== undefined && introEndsWith(latinLower(intro), word));
 };
 
-/** The date is a recurring day or a worked example: a marker stands where its reach covers the date. */
-export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[]): boolean => {
+/**
+ * The date is a recurring day or a worked example: a marker stands where its reach covers the date. `listJoiners` are the
+ * words a `listed` marker may stand before the date with (及び, "and").
+ */
+export const anyYearDate = (date: DateSpan, source: string, markers: readonly AnyYearMarker[], listJoiners: readonly string[] = []): boolean => {
   const before = source.slice(lineStart(source, date.offset), date.offset);
   const intro = introOf(source, before, date.offset);
-  const covered = markers.some(({ word, reach }) => word !== "" && coversDate(before, source.charAt(date.offset), intro, latinLower(word), reach));
+  const joiners = listJoiners.map(latinLower);
+  const covered = markers.some(({ word, reach }) => word !== "" && coversDate(before, source.charAt(date.offset), intro, latinLower(word), reach, joiners));
   return covered || continuesExample(date, before, source, markers);
 };
 

package/src/detectors/date-format.ts

@@ -22,7 +22,8 @@ export const dateFormat: Detector = (doc, options): Finding[] => {
     eras: (doc.lexicons["calendar-era"] ?? []).map((entry) => entry.pattern),
   };
   const text = doc.prose ?? doc.source;
-  return dateGroups(text, datesIn(text, words)).flatMap((group) => {
+  const stampLabels = (doc.lexicons["date-stamp-label"] ?? []).map((entry) => entry.pattern);
+  return dateGroups(text, datesIn(text, words), stampLabels).flatMap((group) => {
     const minority = dateMinority(group, options.limit);
     return minority === undefined ? [] : findingsOf(doc, minority);
   });