chaffjs 0.35.0 → 0.37.0

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/capitalised-term.ts

@@ -28,6 +28,10 @@ export type CapitalisedWords = {
   readonly capacityMarkers: readonly string[];
   /** Articles, which may stand between a capacity word and the capacity (as the Borrower). */
   readonly articles: readonly string[];
+  /** Words right after a run that say it is attached (Termination Certificate attached hereto). */
+  readonly attachedCues: readonly string[];
+  /** Last words of a run that name a kind of document (Certificate, Form): with attachedCues after, the run is a title. */
+  readonly attachedTitleEnds: readonly string[];
 };
 
 /** A term the document defines; bare is a definition with no defining word (("GPC")), which names more than it defines. */
@@ -216,9 +220,26 @@ const capacityOfAName = (tokens: readonly Token[], start: number, words: Capital
   return words.capacityMarkers.includes(marker.surface) && (continues(name) || name.surface === ".");
 };
 
+/** Words right after a run that say it is attached (the Certificate attached hereto), ending at a word's edge. */
+const attachedAfterPattern = (cues: readonly string[]): RegExp | undefined => {
+  const words = cues.filter((cue) => cue !== "").map(escapeRegExp);
+  return words.length === 0 ? undefined : new RegExp(String.raw`^[ \t]+(?:${words.join("|")})(?![\p{L}\p{N}_])`, "u");
+};
+
+/**
+ * The run is the title of a document the agreement attaches: its last word names a kind of document (Certificate,
+ * Form) and words right after it say it is attached. Confidential Information attached hereto is no title.
+ */
+const titlesAttachment = (words: CapitalisedWords): ((last: Token, after: string) => boolean) => {
+  const attached = attachedAfterPattern(words.attachedCues);
+  const titleEnds = new Set(words.attachedTitleEnds);
+  return (last, after) => attached !== undefined && titleEnds.has(last.surface) && attached.test(after);
+};
+
 /**
  * Whether a run is a name by what surrounds it: a number after it, a longer name it starts, brackets after it that
- * define it, initials that spell a term the document defines (“IRS” means the Internal Revenue Service), or a capacity.
+ * define it, initials that spell a term the document defines (“IRS” means the Internal Revenue Service), a capacity, or
+ * words that make it the title of an attached form.
  */
 type NameCue = (tokens: readonly Token[], start: number, end: number, term: string) => boolean;
 
@@ -226,14 +247,17 @@ const nameCues = (input: CapitalisedInput, joiners: ReadonlySet<string>): NameCu
   const words = input.words;
   const ends = { names: lastWordsOf(words.nameEnds), forms: lastWordsOf(words.formEnds), formEntries: new Set(words.formEnds) };
   const definitionAfter = definitionAfterPattern(words);
+  const attachedTitle = titlesAttachment(words);
   const abbreviations = new Set([...input.defined.map((definition) => definition.term), ...input.named].filter((term) => ACRONYM.test(term)));
   return (tokens, start, end, term) => {
     const last = tokens[end - 1];
     if (last === undefined) return false;
+    const after = input.source.slice(last.span.end, last.span.end + DEFINITION_AFTER_CHARS);
     return (
       numberedName(last, tokens[end]) ||
       startsLongerName(tokens, end, ends, joiners) ||
-      definitionAfter.test(input.source.slice(last.span.end, last.span.end + DEFINITION_AFTER_CHARS)) ||
+      definitionAfter.test(after) ||
+      attachedTitle(last, after) ||
       initialsOf(term, joiners).some((initials) => abbreviations.has(initials)) ||
       capacityOfAName(tokens, start, words)
     );

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,77 @@ 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 whose every line is in capitals and none ends a sentence: a letterhead or an address block at the head
+ * (BOARD OF GOVERNORS / WASHINGTON, D.C. 20551), and a heading a transcript sets in capitals on lines of its own
+ * (OPENING STATEMENT OF HON. JANE DOE, / U.S. SENATOR FROM OHIO). A warning in capitals is sentences, so it is not one. A
+ * document with no sentence has no prose to tell such a paragraph apart from.
+ */
+export const capitalParagraphSpans = (source: string): Span[] => {
+  const paragraphs = paragraphsOf(linesOf(source));
+  const endsSentence = (paragraph: readonly Line[]): boolean => paragraph.some((line) => SENTENCE_END.test(line.text));
+  if (!paragraphs.some(endsSentence)) return [];
+  return paragraphs.filter((paragraph) => paragraph.every(isCapitalLine) && !endsSentence(paragraph)).flatMap(spanOf);
+};
+
+/** The capital paragraphs and the roster names of a source, in order of where they start. */
+export const capitalLineSpans = (source: string): Span[] =>
+  [...capitalParagraphSpans(source), ...rosterNameSpans(source)].sort((left, right) => left.start - right.start);
+
+/** The index of the last span that starts at or before at, by halving: -1 when none does. */
+const lastStartingBy = (spans: readonly Span[], at: number, low = 0, high = spans.length): number => {
+  if (low >= high) return low - 1;
+  const middle = Math.floor((low + high) / 2);
+  return (spans[middle]?.start ?? 0) <= at ? lastStartingBy(spans, at, middle + 1, high) : lastStartingBy(spans, at, low, middle);
+};
+
+/** Whether inner lies wholly in one of the spans, which do not overlap and are sorted by start (capitalLineSpans). */
+export const isWithinSorted = (spans: readonly Span[], inner: Span): boolean => {
+  const span = spans[lastStartingBy(spans, inner.start)];
+  return span !== undefined && inner.end <= span.end;
+};
+
+/** Columns on a line: two spaces or more, or a tab, stand between them. */
+const COLUMN_CELL = /[^\t ]+(?: [^\t ]+)*/gu;
+/** A name in capitals, a comma, and a place or office in ordinary case: JANE Q. DOE, Ohio / JOHN DOE, JR., New Mexico. */
+const ROSTER_CELL = /^([A-Z][A-Z.'’-]*(?: [A-Z][A-Z.'’-]*)*(?:, [JS]R\.)?), \p{Lu}\p{Ll}+(?: \p{Lu}\p{Ll}+)*$/u;
+
+/**
+ * The names of a roster: a column that holds a name in capitals and the member's place in ordinary case (a committee's
+ * members, as a hearing sets them). A run in capitals followed by a comma and prose is no roster.
+ */
+export const rosterNameSpans = (source: string): Span[] =>
+  linesOf(source).flatMap((line) =>
+    [...line.text.matchAll(COLUMN_CELL)].flatMap((cell) => {
+      const name = ROSTER_CELL.exec(cell[0])?.[1];
+      const start = line.start + cell.index;
+      return name === undefined ? [] : [{ start, end: start + name.length }];
+    }),
+  );

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,8 @@
 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, type AddresseeSuffix } from "./addressee-edge.ts";
+import { leadingPrefix, trailingTitle, type AddresseeWords } from "./addressee-title-edge.ts";
 import { maskAddresses } from "../address-chain.ts";
 import { isAddressRun } from "./place-run.ts";
 import { isOneName } from "./name-run.ts";
@@ -21,8 +23,15 @@ const KANJI_RUN = /[一-鿿]+/gu;
 /**
  * 漢字の連なりと、その文書全体の座標での範囲。quoted は括弧の中身がまるごとこの連なりであること。
  * placed は、題の名前の置き方（括弧を閉じる、補いの括弧が続く、文がこれだけ）をしていること。
+ * after は、連なりが文の頭にあるときの、その後ろの文字（宛名の行の、空白と「殿」）。頭になければ undefined。
  */
-type KanjiRun = { readonly text: string; readonly span: Span | undefined; readonly quoted: boolean; readonly placed: boolean };
+type KanjiRun = {
+  readonly text: string;
+  readonly span: Span | undefined;
+  readonly quoted: boolean;
+  readonly placed: boolean;
+  readonly after: string | undefined;
+};
 
 const SPACE = /\s/gu;
 
@@ -47,14 +56,27 @@ const runsOf = (sentence: Sentence, profile: DocumentProfile | undefined, names:
   return [...maskedProse(prose, profile, names).matchAll(KANJI_RUN)].map((match) => {
     const before = prose.slice(0, match.index).replace(SPACE, "").length;
     const [start, last] = [printed[before], printed[before + match[0].length - 1]];
-    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false, placed: false };
+    if (start === undefined || last === undefined) return { text: match[0], span: undefined, quoted: false, placed: false, after: undefined };
     const span = { start: sentence.span.start + start, end: sentence.span.start + last + 1 };
-    return { text: match[0], span, quoted: fillsQuote(sentence, start, last + 1), placed: isTitlePosition(sentence.text, start, last + 1) };
+    const after = sentence.text.slice(0, start).trim() === "" ? sentence.text.slice(last + 1) : undefined;
+    return { text: match[0], span, quoted: fillsQuote(sentence, start, last + 1), placed: isTitlePosition(sentence.text, start, last + 1), after };
   });
 };
 
 /** 連なりを数えないと決める語彙: 住所の先頭にしか来ない単位（都道府県）と、組織の名前の形と単位と、題の名前を閉じる語。 */
-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[];
+  /** 宛名の並びの、組織の名前の前の「各」と後ろの役職（各…学校長、…協会会長）。 */
+  readonly addressees: AddresseeWords;
+};
+
+type Tail = AddresseeSuffix;
 
 /** 1 つの文書で連なりを読むのに要るもの。titled は、文書の中で題として置かれた名前（titledNames）。 */
 type RunContext = {
@@ -84,18 +106,44 @@ const isTitle = (tokens: readonly Token[], span: Span, text: string, placed: boo
   ) &&
   (placed || isTitledName(text, context.titled));
 
+/** 宛名の行（各国公私立高等専門学校長、…協会会長 殿）: 連なりが行の頭にあり、後ろは空白と宛先に付く語だけ。 */
+const isAddresseeLine = (run: KanjiRun, words: NameWords): boolean => {
+  const after = run.after?.trim();
+  return after !== undefined && (after === "" || words.addressee.includes(after));
+};
+
+/** 尻の外す語: 数に付く接頭の語か宛先に付く語と、宛名の行ならその前の役職（日本博物館協会会長殿の「会長殿」）。 */
+const tailOf = (tokens: readonly Token[], run: KanjiRun, span: Span, words: NameWords): Tail | undefined => {
+  const prefix = trailingPrefix(tokens, span.end, run.text);
+  const suffix = prefix === undefined ? trailingAddressee(tokens, span.end, run.text, words.addressee) : { surface: prefix.surface, start: prefix.span.start };
+  const title = isAddresseeLine(run, words) ? trailingTitle(run.text.slice(0, run.text.length - (suffix?.surface.length ?? 0)), words.addressees) : undefined;
+  if (title === undefined) return suffix;
+  return { surface: title + (suffix?.surface ?? ""), start: (suffix?.start ?? span.end) - title.length };
+};
+
+/** 外す語を外した残り。頭の「各」は、宛名の行でなければ、残りが名前と決まったときだけ外す（呼び出し側が戻す）。 */
+type Measured = { readonly rest: Span; readonly text: string; readonly keptHead: string };
+
+const measuredOf = (tokens: readonly Token[], run: KanjiRun, span: Span, words: NameWords): Measured => {
+  const tail = tailOf(tokens, run, span, words);
+  const name = run.text.slice(0, run.text.length - (tail?.surface.length ?? 0));
+  const counter = leadingCounter(tokens, span.start, run.text, words.positional);
+  const prefix = counter === undefined ? leadingPrefix(tokens, span.start, name, words.addressees) : undefined;
+  const head = counter ?? prefix;
+  const keptHead = prefix !== undefined && !isAddresseeLine(run, words) ? prefix.surface : "";
+  return { rest: { start: head?.span.end ?? span.start, end: tail?.start ?? span.end }, text: name.slice(head?.surface.length ?? 0), keptHead };
+};
+
 /**
- * 数えない連なりは空。頭の、数に付いた助数詞（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 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));
-  return isPlaceName(tokens, rest, context.words) || isTitle(tokens, rest, text, run.placed, context) ? "" : text;
+  const { rest, text, keptHead } = measuredOf(tokens, run, run.span, context.words);
+  return isPlaceName(tokens, rest, context.words) || isTitle(tokens, rest, text, run.placed, context) ? "" : keptHead + text;
 };
 
 const longestKanji = (sentence: Sentence, context: RunContext): string =>
@@ -118,10 +166,18 @@ const titledNames = (doc: ProseDocument, profile: DocumentProfile | undefined, n
  */
 export const kanjiRun: Detector = (doc, options): Finding[] => {
   const patterns = (id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+  const organisation: OrganisationWords = {
+    forms: patterns("organisation-form"),
+    closingForms: (doc.lexicons["organisation-form"] ?? []).filter((entry) => entry.position !== "before").map((entry) => entry.pattern),
+    units: patterns("organisation-unit"),
+  };
   const words: NameWords = {
     topUnits: new Set(patterns("prefecture-unit")),
-    organisation: { forms: patterns("organisation-form"), units: patterns("organisation-unit") },
+    organisation,
     title: { endings: patterns("title-ending") },
+    positional: patterns("calendar-unit"),
+    addressee: patterns("addressee-suffix"),
+    addressees: { prefixes: patterns("addressee-prefix"), titles: patterns("addressee-title"), endings: organisation.units, forms: organisation.closingForms },
   };
   const names = doc.names ?? [];
   const context: RunContext = { profile: doc.profile, names, words, titled: titledNames(doc, doc.profile, names) };
@@ -141,10 +197,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 +212,4 @@ export const middleDot: Detector = (doc, options): Finding[] =>
       quote: sentence.text.trim(),
       values: { count, limit: options.limit, offset: sentence.span.start },
     }));
+};

package/src/detectors/citation-sentence.ts

@@ -0,0 +1,44 @@
+// A bibliographic citation written out as a sentence, as in a footnote: authors and the year in parentheses, then a title
+// or a publisher. Its length is the length of the reference, not of the writer's prose. Pure.
+import { escapeRegExp } from "../orthography.ts";
+
+/** "Keys and Reina (2025)," or "Federal Housing Finance Agency (n.d.),": the year in parentheses, a comma after it. */
+const AUTHOR_YEAR = /\((?:\d{4}[a-z]?|n\.d\.)\),/gu;
+
+/** What only a reference carries: a quoted title right after the year, a place and its publisher, or a page range. */
+const PUBLICATION_MARKS: readonly RegExp[] = [
+  /\((?:\d{4}[a-z]?|n\.d\.)\),\s*["“]/u,
+  /\(\p{Lu}[\p{L}.'’-]*(?:,?\s\p{Lu}[\p{L}.'’-]*)*:\s\p{Lu}[^()]*\)/u,
+  /\bpp?\.\s*\d+\s*[-–−]\s*\d+/u,
+];
+
+/** Where the citation's year stands: the last year before the first mark of a publication, or the first year when none is before it. */
+const citationYearAt = (text: string): number | undefined => {
+  const years = [...text.matchAll(AUTHOR_YEAR)].map((match) => match.index);
+  const marks = PUBLICATION_MARKS.flatMap((mark) => {
+    const found = mark.exec(text);
+    return found === null ? [] : [found.index + found[0].length];
+  });
+  if (years.length === 0 || marks.length === 0) return undefined;
+  const firstMark = Math.min(...marks);
+  return years.filter((at) => at < firstMark).at(-1) ?? years[0];
+};
+
+export const isCitationSentence = (text: string): boolean => citationYearAt(text) !== undefined;
+
+const signalPattern = (signals: readonly string[]): RegExp | undefined =>
+  signals.length === 0 ? undefined : new RegExp(String.raw`(?<![\p{L}\p{N}])(?:${signals.map(escapeRegExp).join("|")})(?![\p{L}\p{N}])`, "giu");
+
+/**
+ * The writer's own words in a citation sentence: what comes before the last citation signal ("see", from the language's
+ * word list) ahead of the citation's year, or everything before the year when no signal stands there (the authors' names
+ * are short). "For example, see Lisa Cook (2024), …" leads with "For example,". Undefined when the sentence is not a citation.
+ */
+export const citationLead = (text: string, signals: readonly string[]): string | undefined => {
+  const yearAt = citationYearAt(text);
+  if (yearAt === undefined) return undefined;
+  const beforeYear = text.slice(0, yearAt);
+  const pattern = signalPattern(signals);
+  const lastSignal = pattern === undefined ? undefined : [...beforeYear.matchAll(pattern)].at(-1);
+  return (lastSignal === undefined ? beforeYear : beforeYear.slice(0, lastSignal.index)).trim();
+};

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/contraction-mention.ts

@@ -0,0 +1,24 @@
+import { quotedSpans } from "../quoted-span.ts";
+
+// A short phrase in quotation marks ("Do Not Disturb", ‘we’re going to x’) is a name or an example: the form is mentioned,
+// not used, so it says nothing about the document's register. Spoken words carry punctuation ("We don't know," she
+// said) and stay. The text must already have straight apostrophes, so a ’ left in it closes a quotation.
+
+const MENTION_MARKS: Readonly<Record<string, string>> = { "“": "”", '"': '"', "‘": "’" };
+/** More words than this in quotation marks is a quoted sentence, not a phrase named as an example. */
+const MAX_MENTION_WORDS = 4;
+const PHRASE = /^[\p{L}' ]+$/u;
+
+const isMention = (quoted: string): boolean => {
+  const phrase = quoted.trim();
+  return PHRASE.test(phrase) && phrase.split(/\s+/u).length <= MAX_MENTION_WORDS;
+};
+
+/** The text with each quoted short phrase blanked out, every other character at its place. */
+export const withoutMentions = (text: string): string => {
+  const mentions = quotedSpans(text, MENTION_MARKS).filter((span) => isMention(text.slice(span.start, span.end)));
+  if (mentions.length === 0) return text;
+  const units = text.split("");
+  mentions.forEach((span) => units.fill(" ", span.start, span.end));
+  return units.join("");
+};

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/dash-break.ts

@@ -0,0 +1,45 @@
+// A dash with space on both sides after the last comma before an and / or ("Washington, DC – The Cybersecurity and
+// Infrastructure Security Agency"). The dash closes off what came before it, a dateline here, so the commas before it
+// do not separate the items of a list the and / or ends. Commas and dashes inside brackets or quotation marks are not
+// the and / or's own. Pure, and one pass over the sentence.
+import type { Token } from "../plugin.ts";
+
+const DASHES = new Set(["–", "—", "―", "-", "--"]);
+const OPENERS = new Set(["(", "[", "{", "“"]);
+const CLOSERS = new Set([")", "]", "}", "”"]);
+const SPACE = /\s/u;
+
+const isSpacedDash = (token: Token, source: string): boolean =>
+  DASHES.has(token.surface) && SPACE.test(source.charAt(token.span.start - 1)) && SPACE.test(source.charAt(token.span.end));
+
+/** The last comma and the last spaced dash seen at one depth of brackets. */
+type Seen = { comma: number; dash: number };
+
+type Scan = { depth: number; readonly seen: Seen[]; readonly breaks: boolean[] };
+
+const seenAt = (scan: Scan): Seen => {
+  const seen = scan.seen[scan.depth] ?? { comma: -1, dash: -1 };
+  scan.seen[scan.depth] = seen;
+  return seen;
+};
+
+/**
+ * For each token, whether a spaced dash comes between the last comma before it and it, at its depth, and not right
+ * before it: a dash right before the and / or sets off its last item (the plan, the budget – and the schedule).
+ */
+export const dashBreaks = (tokens: readonly Token[], source: string): boolean[] =>
+  tokens.reduce<Scan>(
+    (scan, token, at) => {
+      if (CLOSERS.has(token.surface)) {
+        scan.seen.length = scan.depth;
+        scan.depth = Math.max(0, scan.depth - 1);
+      }
+      const seen = seenAt(scan);
+      scan.breaks.push(seen.comma !== -1 && seen.dash > seen.comma && seen.dash < at - 1);
+      if (token.surface === ",") seen.comma = at;
+      if (isSpacedDash(token, source)) seen.dash = at;
+      if (OPENERS.has(token.surface)) scan.depth += 1;
+      return scan;
+    },
+    { depth: 0, seen: [], breaks: [] },
+  ).breaks;

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

@@ -13,17 +13,18 @@ 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 };
 
 /** The span of a yearless date in the source. */
 export type DateSpan = { readonly offset: number; readonly end: number };
 
-/** How far apart the two ends of a period may stand: the joiner and a year word (「から翌年」, " to "). */
+/** How far apart the two ends of a period may stand besides the joiner itself: a year word (「から翌年」, " to the next "). */
 const SPAN_GAP_REACH = 12;
 
 /** How many lines above a list item its introducing line is looked for: a longer list is read as no example. */
@@ -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,17 +177,25 @@ 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);
 };
 
 /** The date opens a period whose other end, just after it, follows a joiner (「4月1日から翌年3月31日」). */
 export const opensSpan = (date: DateSpan, next: DateSpan | undefined, source: string, joiners: readonly string[]): boolean => {
-  if (next === undefined || next.offset - date.end > SPAN_GAP_REACH) return false;
+  const longest = Math.max(0, ...joiners.map((joiner) => joiner.length));
+  if (next === undefined || next.offset - date.end > SPAN_GAP_REACH + longest) return false;
   const gap = source.slice(date.end, next.offset).trimStart();
-  return !SENTENCE_END.test(gap) && joiners.some((joiner) => joiner !== "" && gap.startsWith(joiner) && !runsOn(gap, joiner));
+  return (
+    !SENTENCE_END.test(gap) &&
+    joiners.some((joiner) => joiner !== "" && gap.length - joiner.length <= SPAN_GAP_REACH && gap.startsWith(joiner) && !runsOn(gap, joiner))
+  );
 };

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