chaffjs 0.35.0 → 0.36.0

package/src/detectors/date-year.ts

@@ -1,6 +1,7 @@
 // A date written without its year where the reader cannot tell which year it is: the document's dated dates span more
 // than one year, or its dates cross the turn of a year. Pure; reads the date nodes of the structure tree.
-import type { Detector, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, LexiconEntry, ProseDocument, StructureNode } from "../plugin.ts";
+import { isIn } from "../lexicon-genres.ts";
 import { inDocumentOrder } from "../structure/issues.ts";
 import { quoteAt } from "./structure-tree.ts";
 import {
@@ -13,17 +14,29 @@ import {
   type MarkerReach,
 } from "./date-any-year.ts";
 import { datesUnderYearHeadings, yearLabelOf, type HeadingYearWords } from "./date-heading-year.ts";
+import { openingDateOf } from "./opening-date.ts";
+import { withNearestYear } from "../structure/weekday.ts";
 
-/** The words that make a yearless date any year's (毎年, 例えば, "each") and that join a period's two ends (から, "to"). */
-export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[] };
+/**
+ * The words that make a yearless date any year's (毎年, 例えば, "each"), that join a period's two ends (から, "to"), and
+ * that join the names of one list (及び, "and"), for a marker named in one list with the date.
+ */
+export type AnyYearWords = { readonly markers: readonly AnyYearMarker[]; readonly joiners: readonly string[]; readonly listJoiners?: readonly string[] };
 
 const NO_ANY_YEAR_WORDS: AnyYearWords = { markers: [], joiners: [] };
 
 /**
  * A date as the tree reads it: "2026-10-14" with its year, "10-14" without. `yearHeaded`: the heading of its section
- * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes.
+ * names a year ("FY27-Q2 (May 1)", 「2026年度の予定」), which the date takes. `nearStamp`: the document's own date (minutes
+ * dated "January 17, 2024") lies within a few months of it in one year only, which the date takes.
  */
-export type DatePoint = { readonly offset: number; readonly end: number; readonly value: string; readonly yearHeaded?: boolean };
+export type DatePoint = {
+  readonly offset: number;
+  readonly end: number;
+  readonly value: string;
+  readonly yearHeaded?: boolean;
+  readonly nearStamp?: boolean;
+};
 
 /** The first and the last year of the document's dated dates. */
 export type YearSpan = { readonly from: number; readonly to: number };
@@ -118,7 +131,8 @@ const hasYearWord = (point: DatePoint, source: string, yearWords: readonly YearW
  */
 const yearGiven = (point: DatePoint, anchors: readonly DatePoint[], source: string, yearWords: readonly YearWord[]): boolean => {
   const start = lineStart(source, point.offset);
-  return point.yearHeaded === true || hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
+  const placed = point.yearHeaded === true || point.nearStamp === true;
+  return placed || hasYearWord(point, source, yearWords) || anchors.some((other) => other.offset >= start && other.offset < point.offset);
 };
 
 const DAY_MS = 24 * 60 * 60 * 1000;
@@ -153,10 +167,14 @@ export const yearGaps = (
   const previousOf = new Map(points.map((point, index) => [point, points[index - 1]]));
   const yearlySpan = (start: DatePoint | undefined, end: DatePoint | undefined): boolean =>
     start !== undefined && end !== undefined && wholeYear(start.value, end.value) && opensSpan(start, end, source, anyYear.joiners);
+  const markedAnyYear = (point: DatePoint | undefined): boolean => point !== undefined && anyYearDate(point, source, anyYear.markers, anyYear.listJoiners);
   const yearOfAny = (point: DatePoint): boolean => {
     const next = nextOf.get(point);
-    if (anyYearDate(point, source, anyYear.markers)) return true;
-    if (yearlySpan(point, next) || yearlySpan(previousOf.get(point), point)) return true;
+    const previous = previousOf.get(point);
+    if (markedAnyYear(point)) return true;
+    if (yearlySpan(point, next) || yearlySpan(previous, point)) return true;
+    // The end of a period whose start is any year's is too: 「祝休日及び12月29日から1月3日まで」.
+    if (previous !== undefined && opensSpan(previous, point, source, anyYear.joiners) && markedAnyYear(previous)) return true;
     return next !== undefined && opensSpan(point, next, source, anyYear.joiners) && hasYearWord(next, source, yearWords);
   };
   // A recurring day or an example's date has no year to write, and is not the document's way of writing dates either.
@@ -172,15 +190,41 @@ export const yearGaps = (
 
 const NO_HEADING_YEAR_WORDS: HeadingYearWords = { eras: [], labels: [] };
 
-export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS): DatePoint[] => {
+/** A yearless date that the document's own date ("2024-01-17") places in one year: within a few months of it. */
+const nearStampOf = (value: string, stamp: string | undefined): boolean => stamp !== undefined && withNearestYear(value, stamp) !== undefined;
+
+export const datePoints = (tree: StructureNode, headingWords: HeadingYearWords = NO_HEADING_YEAR_WORDS, stamp?: string): DatePoint[] => {
   const yearHeaded = new Set(datesUnderYearHeadings(tree, headingWords));
-  return inDocumentOrder(tree).flatMap((node) =>
-    node.kind === "date"
-      ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]), yearHeaded: yearHeaded.has(node.span.start) }]
-      : [],
-  );
+  return inDocumentOrder(tree).flatMap((node) => {
+    if (node.kind !== "date") return [];
+    const value = String(node.attrs["value"]);
+    return [{ offset: node.span.start, end: node.span.end, value, yearHeaded: yearHeaded.has(node.span.start), nearStamp: nearStampOf(value, stamp) }];
+  });
 };
 
+/**
+ * The document's own date: a date alone, or labelled, on a line of its title block. A date-only paragraph further down
+ * (an agenda's "April 4, 2023") is a date the text talks about, not the document's.
+ */
+const stampOf = (doc: ProseDocument, tree: StructureNode): string | undefined => {
+  const dates = inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ ...node.span, value: String(node.attrs["value"]) }] : []));
+  const labels = (doc.lexicons["date-stamp-label"] ?? []).map((entry: LexiconEntry) => entry.pattern);
+  return openingDateOf(doc.source, dates, labels);
+};
+
+/**
+ * The genres whose date at the top is the occasion the text is about (minutes, a letter), from the rule's dated_genres.
+ * A web page's date at the top says when it was posted, and its days and months may be any year's.
+ */
+const datedByOccasion = (options: DetectorOptions): boolean => {
+  const genres = options.settings?.["dated_genres"];
+  const genre = options.genre;
+  return genre !== undefined && Array.isArray(genres) && genres.some((target: string) => isIn(genre, target));
+};
+
+const pointsOf = (doc: ProseDocument, tree: StructureNode, options: DetectorOptions): DatePoint[] =>
+  datePoints(tree, headingYearWordsOf(doc), datedByOccasion(options) ? stampOf(doc, tree) : undefined);
+
 const yearWordsOf = (doc: ProseDocument): YearWord[] =>
   (doc.lexicons[YEAR_REFERENCE_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, position: entry.position }));
 
@@ -192,17 +236,21 @@ const headingYearWordsOf = (doc: ProseDocument): HeadingYearWords => ({
   ),
 });
 
+/** The words that join the names of one list (及び, "and"): a `listed` marker stands before the date with these between. */
+const LIST_JOINER_LEXICON = "enumeration-joiner";
+
 const reachOf = (group: string | undefined): MarkerReach => MARKER_REACHES.find((reach) => reach === group) ?? "sentence";
 
 const anyYearWordsOf = (doc: ProseDocument): AnyYearWords => ({
   markers: (doc.lexicons[ANY_YEAR_MARKER_LEXICON] ?? []).map((entry: LexiconEntry) => ({ word: entry.pattern, reach: reachOf(entry.group) })),
   joiners: (doc.lexicons[YEAR_SPAN_JOINER_LEXICON] ?? []).map((entry: LexiconEntry) => entry.pattern),
+  listJoiners: (doc.lexicons[LIST_JOINER_LEXICON] ?? []).map((entry: LexiconEntry) => entry.pattern),
 });
 
-export const dateWithoutYear: Detector = (doc: ProseDocument): Finding[] =>
+export const dateWithoutYear: Detector = (doc: ProseDocument, options: DetectorOptions): Finding[] =>
   doc.structure === undefined
     ? []
-    : yearGaps(datePoints(doc.structure, headingYearWordsOf(doc)), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
+    : yearGaps(pointsOf(doc, doc.structure, options), doc.source, yearWordsOf(doc), anyYearWordsOf(doc)).map((gap) => ({
         rule: "date-without-year",
         severity: "warning",
         line: 0,

package/src/detectors/deadline-unit.ts

@@ -0,0 +1,40 @@
+import type { Span } from "../plugin.ts";
+
+// The unit a duty is written in: its article, else its list, else its paragraph. A duty in a unit that names the dated
+// deadline of its own act is timed by it: 「乙は代金を支払う。」 beside 「支払期日までに支払うことができないときは…」. A date
+// for another act (a delivery date beside a duty to pay) times nothing. Pure.
+
+/** The spans a document is cut into, from the widest kind that counts as one unit to the narrowest. */
+export type Units = { readonly articles: readonly Span[]; readonly lists: readonly Span[]; readonly paragraphs: readonly Span[] };
+
+/** A dated deadline's name (支払期日, due date) and the act it times (支払, pay). */
+export type NamedDeadline = { readonly name: string; readonly act: string };
+
+const within = (span: Span, offset: number): boolean => offset >= span.start && offset < span.end;
+
+/** The innermost span holding the offset: an article nested in another is a unit of its own. */
+const innermost = (spans: readonly Span[], offset: number): Span | undefined =>
+  spans
+    .filter((span) => within(span, offset))
+    .reduce<Span | undefined>((inner, span) => (inner === undefined || span.start > inner.start ? span : inner), undefined);
+
+/** The unit that holds the offset: its article, else its list, else its paragraph; undefined when none does. */
+export const unitAt = (units: Units, offset: number): Span | undefined =>
+  [units.articles, units.lists, units.paragraphs].map((spans) => innermost(spans, offset)).find((span) => span !== undefined);
+
+/**
+ * The acts whose dated deadline the unit holding the offset names. holds: whether a text holds a name (as a phrase, so
+ * that a Latin name is read as whole words).
+ */
+export const actsTimedAt = (
+  source: string,
+  units: Units,
+  offset: number,
+  deadlines: readonly NamedDeadline[],
+  holds: (text: string, name: string) => boolean,
+): string[] => {
+  const unit = unitAt(units, offset);
+  if (unit === undefined) return [];
+  const text = source.slice(unit.start, unit.end);
+  return [...new Set(deadlines.filter((deadline) => holds(text, deadline.name)).map((deadline) => deadline.act))];
+};

package/src/detectors/defined-term-form.ts

@@ -1,12 +1,14 @@
 // A defined term used later in another form, and a long name used again after its short name was defined. Pure. The
 // definitions come from the document's structure tree (以下「甲」という, ("Seller")); which words may stand in a long
 // name is read from the tokens' parts of speech.
+import { inEntryOfTerm } from "./term-mention-sentence.ts";
 import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../structure/definition-use.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
 import { isPartOfAddress } from "./address-word.ts";
 import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
+import { headsKindPhrase, insideLongerTerm, isNamedAsTerm, isNarrowedUse } from "./ordinary-phrase.ts";
 import { CLOSES_SENTENCE, isNameField, isSignatureLine, opensClosingBlock, SLACK } from "./name-field.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
@@ -146,18 +148,36 @@ const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: De
         ),
   );
 
-/** The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは). */
-const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] =>
-  doc.profile?.quoteMentionsTerm === true
-    ? []
-    : quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
-        finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
-      );
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/**
+ * The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは),
+ * or the words before the quote name it as a term (the definition of "Material Adverse Effect").
+ */
+const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] => {
+  if (doc.profile?.quoteMentionsTerm === true) return [];
+  const cues = patternsOf(doc, "term-mention-cue");
+  return quotedUses(doc.source, term.term, uses, definingEnd)
+    .filter((offset) => !isNamedAsTerm(doc.source, offset - 1, cues))
+    .map((offset) => finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }));
+};
+
+/**
+ * A lower-case use that is the ordinary word in a phrase of its own: inside another defined term (certificate of merger),
+ * narrowed by the word before it (the common parent), or heading a kind of thing (certificates of deposit).
+ */
+const isOrdinaryPhraseAt = (doc: ProseDocument, offset: number, term: string, defined: readonly string[]): boolean => {
+  if (insideLongerTerm(doc.source, offset, term, defined)) return true;
+  const { tokens, at } = tokensAt(doc, offset);
+  if (at === -1) return false;
+  const last = tokens.findLastIndex((token) => token.span.start < offset + term.length);
+  return isNarrowedUse(tokens, at, patternsOf(doc, "defined-term-pointer")) || headsKindPhrase(tokens, last);
+};
 
 /** The term written longer with a word of its definition (文書管理責任者, the Application), after the sentence that defines it. */
 const extendedFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, spans: readonly Span[], defined: readonly string[]): Finding[] => {
   const definition = definingSentence(doc, term.span)?.text ?? "";
-  const pointers = (doc.lexicons["defined-term-pointer"] ?? []).map((entry) => entry.pattern);
+  const pointers = patternsOf(doc, "defined-term-pointer");
   // Every sentence that defines the term (a second definition too) holds the long words it is defined from.
   const defining = spans.map((span) => definingSentence(doc, span)?.span ?? span);
   const definingEnd = definingSentenceEnd(doc, term.span);
@@ -182,11 +202,11 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
     const quoted = quotedFindings(doc, term, uses, definingEnd);
-    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses);
+    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses).filter((offset) => !inEntryOfTerm(doc.sentences, term.term, offset));
     const nounUses = caseUses.filter((offset) => !isVerbAt(doc, offset));
-    const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
-      finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
-    );
+    const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit)
+      .filter((offset) => !isOrdinaryPhraseAt(doc, offset, term.term, defined))
+      .map((offset) => finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }));
     return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined), ...extendedFindings(doc, texts, term, spans, defined)];
   });
 };

package/src/detectors/definition-use.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type IsTitle, type Mentioned } from "../structure/definition-use.ts";
 import { titleLineNumbers } from "../structure/title-lines.ts";
+import { contentsLineNumbers } from "../structure/contents-lines.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -34,10 +35,13 @@ export const unusedDefinition: Detector = (doc): Finding[] =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 
-/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）と、目次・索引の行の上の位置か。 */
 const titleIn = (doc: ProseDocument): IsTitle => {
   const lines = linesOf(doc.source);
-  const numbers = titleLineNumbers(doc.structure, lines, doc.markup?.headings ?? []);
+  const headings = doc.markup?.headings ?? [];
+  const numbers = new Set([...titleLineNumbers(doc.structure, lines, headings), ...contentsLineNumbers(lines, headings, patternsOf(doc, "toc-heading"))]);
   return (offset) => numbers.has(lineNumberAt(lines, offset) ?? 0);
 };
 
@@ -45,7 +49,7 @@ const titleIn = (doc: ProseDocument): IsTitle => {
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc)).map((use) =>
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc), patternsOf(doc, "self-prefix")).map((use) =>
         findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
       );
 

package/src/detectors/derived-numbers.ts

@@ -4,6 +4,8 @@ import { documentDateOf } from "./document-date.ts";
 import { overlapsAny, spanIndex } from "../compare/spans.ts";
 import { yearOf, type DurationUnit } from "../derived/date-arithmetic.ts";
 import { durationMismatches, type DatedValue, type Duration } from "../derived/durations.ts";
+import { isCountPerPeriod, type PeriodWord, type PerPeriodWords } from "../derived/count-per-period.ts";
+import { occurrences } from "../structure/stated-multiple.ts";
 import { elapsedMismatches, type Elapsed, type OriginWord, type Year } from "../derived/elapsed.ts";
 import { numberWordCounts } from "../derived/number-word-counts.ts";
 import { hyphenatedCounts, withoutArticle } from "../derived/hyphenated-counts.ts";
@@ -91,12 +93,25 @@ const isApproximate = (doc: ProseDocument, span: Attributed): boolean =>
   positioned(doc, "approximate-marker", "before").some((word) => textBefore(doc, span).endsWith(word)) ||
   positioned(doc, "approximate-marker", "after").some((word) => textAfter(doc, span).startsWith(word));
 
-/** 木の数量（3 months）と、名詞の前に書いた期間（a 3-month trial）。 */
-const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[], text: string): Duration[] =>
-  [...quantities, ...hyphenatedCounts(text, patternsOf(doc, ...DURATION_LEXICONS.map(([id]) => id)))].flatMap((quantity) => {
+const isDurationUnit = (group: string | undefined): group is DurationUnit => DURATION_LEXICONS.some(([, unit]) => unit === group);
+
+const perPeriodWordsOf = (doc: ProseDocument): PerPeriodWords => ({
+  periods: (doc.lexicons["duration-per-period"] ?? []).flatMap((entry): PeriodWord[] =>
+    isDurationUnit(entry.group) ? [{ word: entry.pattern.toLowerCase(), position: entry.position === "after" ? "after" : "before", unit: entry.group }] : [],
+  ),
+  schedules: spanIndex(occurrences(doc.source, patternsOf(doc, "weekly-days-off"))),
+});
+
+/** 木の数量（3 months）と、名詞の前に書いた期間（a 3-month trial）。期間あたりの数（週3日）は期間ではない。 */
+const durationsOf = (doc: ProseDocument, quantities: readonly Quantity[], text: string): Duration[] => {
+  const perPeriod = perPeriodWordsOf(doc);
+  return [...quantities, ...hyphenatedCounts(text, patternsOf(doc, ...DURATION_LEXICONS.map(([id]) => id)))].flatMap((quantity) => {
     const unit = DURATION_LEXICONS.find(([id]) => patternsOf(doc, id).some((pattern) => pattern.normalize("NFKC") === quantity.unit))?.[1];
-    return unit === undefined || isApproximate(doc, quantity) ? [] : [{ ...quantity, unit }];
+    if (unit === undefined || isApproximate(doc, quantity)) return [];
+    const duration = { ...quantity, unit };
+    return isCountPerPeriod(duration, textBefore(doc, quantity), textAfter(doc, quantity), perPeriod) ? [] : [duration];
   });
+};
 
 const sentencesOf = (doc: ProseDocument): Span[] => doc.sentences.map((sentence) => sentence.span);
 

package/src/detectors/doubled-across-aside.ts

@@ -0,0 +1,36 @@
+import type { Token } from "../plugin.ts";
+
+// 同じ助詞のあいだに括弧の注だけがある（「本利用規約は(以下、本規約)は」）。注を書き足したときに、前の助詞を消し忘れた跡。
+// 「AはBは」の対比は、あいだに語があるので当たらない。
+
+const MAX_ASIDE = 80;
+/** 注の前後に置ける空白（行の中だけ）。 */
+const MAX_SPACES = 2;
+const SPACES = `[ \\t\\u3000]{0,${String(MAX_SPACES)}}`;
+/** 助詞の後ろの、括弧ひとつの注（入れ子でない）とその前後の空白。 */
+const ASIDE = new RegExp(`^${SPACES}[（(][^（()）\\n]{1,${String(MAX_ASIDE)}}[)）]${SPACES}`, "u");
+/** 括弧と注と前後の空白が収まる長さ。これより先は読まない。 */
+const LOOK_AHEAD = MAX_ASIDE + 2 + MAX_SPACES * 2;
+
+/** 「別表の（1）の欄」の「の」は、括弧の番号を挟んで名前を続ける書き方なので数えない。 */
+const JOINS_NAMES = "の";
+
+const isParticle = (token: Token): boolean => token.pos === "ADP" && token.surface !== JOINS_NAMES;
+
+/** 二つの同じ助詞と、そのあいだの括弧の注。 */
+export type AsidePair = { readonly first: Token; readonly second: Token };
+
+/** first の後ろが括弧の注だけで、その直後に同じ助詞があれば、その助詞。source は文書全体で、token の span もその座標。 */
+const particleAfterAside = (source: string, tokens: readonly Token[], first: Token): Token | undefined => {
+  const aside = ASIDE.exec(source.slice(first.span.end, first.span.end + LOOK_AHEAD))?.[0];
+  if (aside === undefined) return undefined;
+  const second = tokens.find((token) => token.span.start === first.span.end + aside.length);
+  return second !== undefined && isParticle(second) && second.surface === first.surface ? second : undefined;
+};
+
+/** 文の語のうち、括弧の注を挟んで同じ助詞が二度ある所。Pure. */
+export const doubledAcrossAside = (source: string, tokens: readonly Token[]): AsidePair[] =>
+  tokens.flatMap((first) => {
+    const second = isParticle(first) ? particleAfterAside(source, tokens, first) : undefined;
+    return second === undefined ? [] : [{ first, second }];
+  });

package/src/detectors/doubled-punctuation.ts

@@ -1,4 +1,6 @@
-import type { Detector, Finding } from "../plugin.ts";
+import type { Detector, Finding, Span } from "../plugin.ts";
+import { latinCompanyFormRegExp, latinCompanyFormSpans } from "../latin-company-form.ts";
+import { firstEndingAfter } from "../soft-break.ts";
 import { quoteAround } from "./quote-around.ts";
 
 /**
@@ -32,16 +34,35 @@ const withoutWordDot = (text: string, found: DoubledMarks): DoubledMarks =>
     ? { start: found.start, run: found.run.slice(0, -1) }
     : found;
 
-const isSlip = (text: string, { start, run }: DoubledMarks): boolean =>
-  run.length >= 2 && !isDrawnOut(run) && !isDrawnOutThenClosed(run) && !AFTER_ABBREVIATION.test(run) && !isJoinedDots(text, start, run);
+/**
+ * 並びのうち、英字の会社の形（CO.，LTD.、INC.）の中の印の数。形の点や「，」は名前の一部で、並びの印ではない。
+ * names は昇順で重ならない（正規表現の順の一致）。並びに掛かりうるのは、並びの終わる前に始まる高々 run.length 個の形。
+ */
+const marksInNames = ({ start, run }: DoubledMarks, names: readonly Span[]): number => {
+  const first = firstEndingAfter(names, start);
+  const near = names.slice(first, first + run.length);
+  return [...run].filter((_, at) => near.some((name) => start + at >= name.start && start + at < name.end)).length;
+};
+
+const isSlip = (text: string, found: DoubledMarks, names: readonly Span[]): boolean => {
+  const { start, run } = found;
+  return (
+    run.length - marksInNames(found, names) >= 2 &&
+    !isDrawnOut(run) &&
+    !isDrawnOutThenClosed(run) &&
+    !AFTER_ABBREVIATION.test(run) &&
+    !isJoinedDots(text, start, run)
+  );
+};
 
-/** text の中の、句読点が重なった並び（位置と並び）。 */
-export const doubledMarks = (text: string): DoubledMarks[] =>
-  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found));
+/** text の中の、句読点が重なった並び（位置と並び）。names は数えない名前（英字の会社の形）の範囲。 */
+export const doubledMarks = (text: string, names: readonly Span[] = []): DoubledMarks[] =>
+  [...text.matchAll(PUNCTUATION_RUN)].map((match) => withoutWordDot(text, { start: match.index, run: match[0] })).filter((found) => isSlip(text, found, names));
 
 export const doubledPunctuation: Detector = (doc): Finding[] => {
   const text = doc.prose ?? doc.source;
-  return doubledMarks(text).map(({ start, run }) => ({
+  const forms = latinCompanyFormRegExp((doc.lexicons["company-form-latin"] ?? []).map((entry) => entry.pattern));
+  return doubledMarks(text, latinCompanyFormSpans(text, forms)).map(({ start, run }) => ({
     rule: "",
     severity: "warning",
     line: 0,

package/src/detectors/doubled-word.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
 import { citedNamesOf, endsCitedName } from "./cited-name.ts";
+import { doubledAcrossAside } from "./doubled-across-aside.ts";
 
 /**
  * 語を書き損じて二度書いた（the the / 資料をを）。消し忘れと、書き換えの途中で残った語（our the platform）の二つ。
@@ -159,7 +160,7 @@ export const doubledWord: Detector = (doc, options): Finding[] => {
   const kinds = new Set((doc.lexicons[DOCUMENT_KIND] ?? []).map((entry) => entry.pattern));
   const phrases = doc.lexicons[FIXED_PHRASE] ?? [];
   return doc.sentences.flatMap((sentence) =>
-    doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases)
+    [...doubledIn(doc.source, sentence.tokens ?? [], spaced, allowed, phrases), ...(spaced ? [] : doubledAcrossAside(doc.source, sentence.tokens ?? []))]
       .filter((doubled) => !endsCitedName(doubled.first, doubled.second, cited, kinds))
       .map((doubled) => findingOf(sentence, doubled, spaced)),
   );

package/src/detectors/ellipsis.ts

@@ -35,6 +35,19 @@ const wordAround = (text: string, start: number, end: number): string => {
   return text.slice(from, after === -1 ? text.length : end + after);
 };
 
+/**
+ * A leader pads a label out to a column: the label opens a line or follows a sentence end, holds no space or punctuation,
+ * and two spaces or more follow the dots (化学品事業…… then two full-width spaces, then the description). One such place
+ * may be an ellipsis followed by spaces; MIN_LEADERS of them are a list of labels.
+ */
+const LEADER_LABEL = /(?:^|[\n。．！？!?])[^\S\n]*[^\s\p{P}]{1,20}$/u;
+const LEADER_PADDING = /^[^\S\n]{2}/u;
+const LABEL_REACH = 24;
+const MIN_LEADERS = 2;
+
+const isLeaderShaped = (text: string, start: number, end: number): boolean =>
+  LEADER_PADDING.test(text.slice(end)) && LEADER_LABEL.test(text.slice(Math.max(0, start - LABEL_REACH), start));
+
 /** Dots that are not an ellipsis in running text: a range, a path or address, a table of contents leader. */
 const isNotProse = (text: string, start: number, end: number): boolean =>
   NOT_PROSE_BESIDE.test(text.charAt(start - 1)) ||
@@ -50,9 +63,11 @@ export const ellipsesIn = (text: string, forms: readonly string[]): WrittenEllip
     .map(escapeRegExp)
     .join("|");
   const pattern = new RegExp(`(?<!${ELLIPSIS_PART})(?:${alternatives})(?!${ELLIPSIS_PART})`, "gu");
-  return [...text.matchAll(pattern)].flatMap((match) =>
+  const found = [...text.matchAll(pattern)].flatMap((match) =>
     isNotProse(text, match.index, match.index + match[0].length) ? [] : [{ offset: match.index, form: match[0] }],
   );
+  const leaders = found.filter((ellipsis) => isLeaderShaped(text, ellipsis.offset, ellipsis.offset + ellipsis.form.length));
+  return leaders.length < MIN_LEADERS ? found : found.filter((ellipsis) => !leaders.includes(ellipsis));
 };
 
 export const ellipsisConsistency: Detector = (doc, options): Finding[] => {

package/src/detectors/email-letter.ts

@@ -1,6 +1,6 @@
 // A work email or letter's own parts: a greeting and a closing, a subject line, and an attachment the text mentions.
 // Pure. The words (お世話になっております, Dear, Best regards, 件名, attached) come from the language's email-greeting,
-// email-closing, email-sentence-end, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
+// email-closing, email-sentence-end, memo-header-label, email-subject-field, attachment-mention, attachment-not-mention and attachment-line lexicons. The
 // header and the signature are masked in doc.prose; a quoted reply is someone else's words and is left out.
 import { escapeRegExp } from "../orthography.ts";
 import { quoteAt } from "./structure-tree.ts";
@@ -141,13 +141,49 @@ export const frameSlips = (
   ];
 };
 
+/** The marks around a label line: a heading's #, emphasis, 【】. */
+const LINE_MARKS = new Set("#*_【】 \t\u3000");
+
+const withoutMarks = (line: string): string => {
+  const chars = [...line];
+  const first = chars.findIndex((char) => !LINE_MARKS.has(char));
+  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !LINE_MARKS.has(char)) + 1).join("");
+};
+
+const LABEL_END = /^(?:[:：]|$)/u;
+
+/** An inline HTML tag around a label (<h3> FROM: <br/>, <b>TO</b>:), dropped so the colon still follows the label. */
+const INLINE_HTML_TAG = /<\/?[A-Za-z][A-Za-z0-9-]*(?:\s[^<>]*)?\/?>/gu;
+
+/**
+ * Whether a line is a memo's header label (TO:, SUBJECT:, MEMORANDUM, 発信者：): a label as the lexicon writes it, case
+ * included, then a colon or the line's end. A memo sets its labels in capitals; a mail program writes "To:" and "Subject:".
+ */
+export const isMemoLabel = (line: string, labels: readonly string[]): boolean => {
+  const bare = withoutMarks(line.replace(INLINE_HTML_TAG, ""));
+  return labels.some((label) => bare.startsWith(label) && LABEL_END.test(bare.slice(label.length)));
+};
+
+/**
+ * A memo: one of its header labels among the source's lines before the first sentence (the first lines, when no line ends
+ * one). The source, not the body, since a block of TO: / FROM: lines is masked as an email's header. A memo takes no
+ * greeting and no closing.
+ */
+export const isMemo = (source: string, labels: readonly string[], sentenceEnds: readonly string[]): boolean => {
+  const lines = source.split("\n").filter((line) => line.trim() !== "" && !line.trimStart().startsWith(">"));
+  const firstSentence = lines.findIndex((line) => endsSentence(line, sentenceEnds));
+  return lines.slice(0, firstSentence === -1 ? HEADER_LINES : firstSentence).some((line) => isMemoLabel(line, labels));
+};
+
+const frameSlipsOf = (doc: ProseDocument): FrameSlip[] => {
+  const sentenceEnds = patternsOf(doc, "email-sentence-end");
+  if (isMemo(doc.source, patternsOf(doc, "memo-header-label"), sentenceEnds)) return [];
+  const lines = bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []);
+  return frameSlips(lines, patternsOf(doc, "email-greeting"), patternsOf(doc, "email-closing"), sentenceEnds);
+};
+
 export const emailFrame: Detector = (doc): Finding[] =>
-  frameSlips(
-    bodyLines(doc.source, doc.prose ?? doc.source, doc.replyQuotes ?? []),
-    patternsOf(doc, "email-greeting"),
-    patternsOf(doc, "email-closing"),
-    patternsOf(doc, "email-sentence-end"),
-  ).map((slip) => ({
+  frameSlipsOf(doc).map((slip) => ({
     rule: "email-greeting-closing",
     severity: "info",
     line: 0,
@@ -180,14 +216,53 @@ export const fieldOf = (line: string): { readonly name: string; readonly value:
       };
 };
 
+/** The subject field's names and reply marks, and what tells the body's first line from a subject: a greeting, a sentence's end. */
+export type SubjectVocabulary = {
+  readonly fields: readonly string[];
+  readonly replyMarks: readonly string[];
+  readonly headerFields: readonly string[];
+  readonly greetings: readonly string[];
+  readonly sentenceEnds: readonly string[];
+};
+
+/** The text of the first line with text after `index`, trimmed. Scans only the blank lines between, so many empty subjects stay linear. */
+const nextText = (lines: readonly SourceLine[], index: number): string => {
+  for (let at = index + 1; at < lines.length; at += 1) {
+    const text = lines[at]?.text.trim() ?? "";
+    if (text !== "") return text;
+  }
+  return "";
+};
+
+/** A header field's line (From: Ann). Not any colon: a subject may hold one (Re: Lunch, 10:00 meeting, Q3: budget). */
+const isHeaderField = (line: string, headerFields: readonly string[]): boolean => {
+  const name = fieldOf(line)?.name.toLowerCase();
+  return name !== undefined && headerFields.some((field) => field.toLowerCase() === name);
+};
+
+/**
+ * The value under a subject label with nothing after its colon: the next line with text, as a form that sets the label and
+ * the value in two columns reads once it is text ("SUBJECT:" over "Car park repairs"). A quoted line, a header field, a
+ * greeting or a sentence there is the body, and the subject stays empty.
+ */
+export const valueBelow = (lines: readonly SourceLine[], index: number, vocabulary: SubjectVocabulary): string => {
+  const text = nextText(lines, index);
+  const isBody =
+    text.startsWith(">") || isHeaderField(text, vocabulary.headerFields) || lineHas(text, vocabulary.greetings) || endsSentence(text, vocabulary.sentenceEnds);
+  return isBody ? "" : text;
+};
+
 /** The subject lines (Subject: …, 件名：…), outside a quoted reply, with reply and forward marks (Re:, Fwd:) taken off the value. */
-export const subjectLines = (source: string, fields: readonly string[], replyMarks: readonly string[], replyQuotes: readonly Span[]): SubjectLine[] => {
-  const names = new Set(fields.map((field) => field.toLowerCase()));
+export const subjectLines = (source: string, vocabulary: SubjectVocabulary, replyQuotes: readonly Span[]): SubjectLine[] => {
+  const names = new Set(vocabulary.fields.map((field) => field.toLowerCase()));
   const quoted = insideCursor(replyQuotes);
-  return linesWithOffsets(source).flatMap(({ start, text }): SubjectLine[] => {
+  const lines = linesWithOffsets(source);
+  return lines.flatMap(({ start, text }, index): SubjectLine[] => {
     const field = fieldOf(text);
     const inQuote = quoted(start);
-    return field === undefined || inQuote || !names.has(field.name.toLowerCase()) ? [] : [{ start, subject: withoutReplyMarks(field.value, replyMarks) }];
+    if (field === undefined || inQuote || !names.has(field.name.toLowerCase())) return [];
+    const value = field.value === "" ? valueBelow(lines, index, vocabulary) : field.value;
+    return [{ start, subject: withoutReplyMarks(value, vocabulary.replyMarks) }];
   });
 };
 
@@ -201,7 +276,17 @@ export const withoutReplyMarks = (subject: string, marks: readonly string[]): st
 };
 
 export const emailSubject: Detector = (doc, options): Finding[] =>
-  subjectLines(doc.source, patternsOf(doc, "email-subject-field"), patternsOf(doc, "email-reply-mark"), doc.replyQuotes ?? []).flatMap((line): Finding[] => {
+  subjectLines(
+    doc.source,
+    {
+      fields: patternsOf(doc, "email-subject-field"),
+      replyMarks: patternsOf(doc, "email-reply-mark"),
+      headerFields: patternsOf(doc, "email-header-field"),
+      greetings: patternsOf(doc, "email-greeting"),
+      sentenceEnds: patternsOf(doc, "email-sentence-end"),
+    },
+    doc.replyQuotes ?? [],
+  ).flatMap((line): Finding[] => {
     const length = [...line.subject].length;
     if (length > 0 && length <= options.limit) return [];
     return [
@@ -228,15 +313,6 @@ export const firstMention = (lines: readonly BodyLine[], mentions: readonly stri
   return line === undefined ? undefined : line.start + line.text.length - line.text.trimStart().length;
 };
 
-/** The marks around a label line: a heading's #, emphasis, 【】. */
-const LINE_MARKS = new Set("#*_【】 \t\u3000");
-
-const withoutMarks = (line: string): string => {
-  const chars = [...line];
-  const first = chars.findIndex((char) => !LINE_MARKS.has(char));
-  return first === -1 ? "" : chars.slice(first, chars.findLastIndex((char) => !LINE_MARKS.has(char)) + 1).join("");
-};
-
 /** A line that labels what is attached: the label and a colon (Attachment: quote.pdf), or the label alone (### Enclosures, 【添付資料】). */
 const labelsAttachment = (line: string, labels: readonly string[]): boolean => {
   const bare = withoutMarks(line).toLowerCase();