chaffjs 0.34.0 → 0.36.0

package/src/detectors/name-variant.ts

@@ -7,7 +7,7 @@ import { lookalikeSlipsIn, type LookalikeChars } from "../name-lookalike-chars.t
 import { givenNameReadingOf, readingOfWords, type CharReadings } from "../name-char-reading.ts";
 import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
-import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper, type PredicateEnds } from "../company-names.ts";
+import { companyMentionsIn, companyVariants, type CompanyForm, type CompanyMention, type IsProper, type PredicateEnds } from "../company-names.ts";
 import { kanaSpelledCompanies, type ReadWord } from "../company-kana-spelling.ts";
 import { proseAndTablesOf } from "../table-text.ts";
 import { tableBodyCells } from "../facts/table-facts.ts";
@@ -23,6 +23,7 @@ import { spacedPersonNamesIn } from "../spaced-person-name.ts";
 import { isOrdinaryToken, withOrdinaryWords } from "../name-ordinary-word.ts";
 import { isInPersonField } from "../person-field.ts";
 import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.ts";
+import { isGroupPairOf, notDefinedTerms, outsideCapitals, sentenceIndexOf, withGivenNames } from "./name-variant-apart.ts";
 
 // 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
 // （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
@@ -145,20 +146,22 @@ const predicateEndsOf = (doc: ProseDocument): PredicateEnds =>
 const readWordsOf = (doc: ProseDocument): ReadWord[] =>
   tokensOf(doc).map((token) => ({ start: token.span.start, end: token.span.end, surface: token.surface, reading: token.reading }));
 
+/** 会社の名前の現れ。大文字で書いた一節の中のものは除く。 */
+const companyMentionsOf = (doc: ProseDocument, prose: string): CompanyMention[] =>
+  outsideCapitals(prose, companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), kanaStopsOf(doc), predicateEndsOf(doc)));
+
 /**
  * 会社の名前の書き分けと、名前の漢字一字をその読みのかなで書いた所（みどり野 と みどりの）。名前の見方がすでに指した所と重なる
  * ものは除く。
  */
-const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
-  const stops = kanaStopsOf(doc);
-  const mentions = companyMentionsIn(prose, [...companyFormsOf(doc), ...foreignFormsOf(doc)], properOf(doc), stops, predicateEndsOf(doc));
+const companyFindings = (doc: ProseDocument, prose: string, mentions: readonly CompanyMention[], reported: readonly Reported[]): Reported[] => {
   const variants = companyVariants(mentions).map(({ mention, usual, kind }) => ({
     offset: mention.offset,
     name: mention.surface,
     usual,
     kind: kind === "spelling" ? kind : `company-${kind}`,
   }));
-  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), stops.particles)
+  const kana = kanaSpelledCompanies(prose, mentions, readWordsOf(doc), kanaStopsOf(doc).particles)
     .map(({ surface, offset, usual }) => ({ offset, name: surface, usual, kind: "company-kana" }))
     .filter((found) => !overlapsAny(variants, found.offset, found.name.length));
   return [...variants, ...kana].filter(({ offset, name }) => !overlapsAny(reported, offset, name.length));
@@ -207,6 +210,9 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
     .map((token) => ({ start: token.span.start, end: token.span.end, key: stemOf(token.surface, suffixes) }));
 };
 
+/** 語彙表 name-title-joiner の、前置詞の後ろにだけ立つ冠詞（the）の組。 */
+const ARTICLE = "article";
+
 /**
  * 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学）。名前と読める所は、括弧の中（name-quote）、大文字で始まる語の並び
  * （name-title-joiner を挟んでよい）、名前を書く欄の後ろ（name-label）。大文字の語の並びどうしは、片方が表の升まるごとに
@@ -214,13 +220,20 @@ const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
  */
 const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
   const starts = sentenceStartsOf(doc);
+  const joiners = doc.lexicons["name-title-joiner"] ?? [];
   const spans = [
     ...quotedSpans(prose, patternsOf(doc, "name-quote")),
-    ...titleCaseSpans(prose, patternsOf(doc, "name-title-joiner"), (offset) => starts.has(offset)),
+    ...titleCaseSpans(
+      prose,
+      joiners.filter((entry) => entry.group !== ARTICLE).map((entry) => entry.pattern),
+      (offset) => starts.has(offset),
+      joiners.filter((entry) => entry.group === ARTICLE).map((entry) => entry.pattern),
+    ),
     ...labelledSpans(prose, patternsOf(doc, "name-label")),
   ];
   const cells = new Set(tableBodyCells(proseAndTablesOf(doc)).map((cell) => cell.text.trim()));
-  return wordOrderVariants(orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)), cells)
+  const names = notDefinedTerms(doc, orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)));
+  return wordOrderVariants(names, cells, sentenceIndexOf(doc))
     .filter(({ name }) => !overlapsAny(reported, name.offset, name.surface.length))
     .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
 };
@@ -270,7 +283,7 @@ const tokenRunsOf = (sentence: Sentence): readonly (readonly Token[])[] => {
 const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars): NameMention[] => {
   const cues: NameCues = { leads: patternsOf(doc, "person-lead"), suffixes: patternsOf(doc, "person-suffix"), particles: patternsOf(doc, "name-particle") };
   const charReadings = charReadingsOf(doc);
-  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, doc.source, cues.suffixes, charReadings)));
+  const tagged = doc.sentences.flatMap((sentence) => tokenRunsOf(sentence).flatMap((tokens) => mentionsIn(tokens, prose, cues.suffixes, charReadings)));
   const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
   const cued = [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)].map((mention): NameMention => {
     const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
@@ -281,7 +294,7 @@ const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars):
   const outside = joined.filter(
     (mention) => !spaced.some((name) => name.offset < mention.offset + mention.surface.length && mention.offset < name.offset + name.surface.length),
   );
-  return withKnownNeighbours([...outside, ...spaced], prose).toSorted((left, right) => left.offset - right.offset);
+  return outsideCapitals(prose, withKnownNeighbours([...outside, ...spaced], prose)).toSorted((left, right) => left.offset - right.offset);
 };
 
 /** 人の名前で形の似た別の字（太 と 大）は語彙表 name-lookalike-char が組（group）ごとに言う。 */
@@ -352,10 +365,15 @@ const wordUseOf = (doc: ProseDocument): WordUse => {
 export const nameVariant: Detector = (doc): Finding[] => {
   const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, nameMentionsOf(doc, prose, chars)));
+  const mentions = labelledNamesOf(doc, ordinaryNamesOf(doc, withGivenNames(tokensOf(doc), doc.source, nameMentionsOf(doc, prose, chars))));
+  const companies = companyMentionsOf(doc, prose);
+  const inGroup = isGroupPairOf(
+    companies,
+    companyFormsOf(doc).map((form) => form.pattern),
+  );
   const variants = nameVariants(mentions, chars, spellingInputOf(doc), wordUseOf(doc))
     .map(({ mention, usual, kind }): Reported => ({ offset: mention.offset, name: mention.surface, usual, kind }))
-    .filter(notSpacingOnly);
+    .filter((found) => notSpacingOnly(found) && !inGroup(found));
   const lookalikes = lookalikeSlipsIn(mentions, lookalikeCharsOf(doc)).map(({ mention, usual }) => ({
     offset: mention.offset,
     name: mention.surface,
@@ -363,7 +381,7 @@ export const nameVariant: Detector = (doc): Finding[] => {
     kind: "lookalike",
   }));
   const names = [...variants, ...lookalikes.filter((found) => !overlapsAny(variants, found.offset, found.name.length))];
-  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, companies, names)];
   const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies).filter(notSpacingOnly)];
   const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables, chars)];
   const withProducts = [...withPlaces, ...productFindings(doc, prose, withPlaces)];

package/src/detectors/notice-paragraph.ts

@@ -0,0 +1,33 @@
+import { entryIn } from "./lexicon-match.ts";
+import type { LexiconEntry, Paragraph, Sentence } from "../plugin.ts";
+
+/** 一文だけの断りは本文の書き損じのことがある。段落ごと別の調子で揃えてあるときだけ、意図した別の声と読む。 */
+const MIN_SENTENCES = 2;
+
+/**
+ * 断り書きの段落（「…無償で提供します。…一切の責任を負いません。…ご了承ください。」）の文。
+ * 免責や変更の予告は、である調の文書でもですます調で書く決まり文句で、本文と文末の調子を比べるものではない。
+ * 断りの語（cues）を含み、調子を持つ文が MIN_SENTENCES 以上あって、それがみな同じ、文書の多いほう（majority）ではない調子の段落だけ。
+ * 調子が混ざった段落と、文書と同じ調子の段落は、本文と同じに数える。
+ */
+export const noticeSentences = <R>(
+  paragraphs: readonly Paragraph[],
+  cues: readonly LexiconEntry[],
+  registerOf: (sentence: Sentence) => R | undefined,
+  majority: R | undefined,
+): Set<Sentence> =>
+  new Set(
+    paragraphs.flatMap((paragraph) => {
+      const registers = new Set(
+        paragraph.sentences.flatMap((sentence) => {
+          const register = registerOf(sentence);
+          return register === undefined ? [] : [register];
+        }),
+      );
+      const counted = paragraph.sentences.filter((sentence) => registerOf(sentence) !== undefined).length;
+      const [only] = registers;
+      const ownVoice = counted >= MIN_SENTENCES && registers.size === 1 && only !== majority;
+      const notice = ownVoice && paragraph.sentences.some((sentence) => cues.some((cue) => entryIn(sentence, cue)));
+      return notice ? paragraph.sentences : [];
+    }),
+  );

package/src/detectors/number-style.ts

@@ -51,12 +51,24 @@ const MAGNITUDES = /^[一百千万億]+$/u;
 
 const isIdiomNumeral = (numeral: string): boolean => MAGNITUDES.test(numeral);
 
-const countMarks = (text: string, base: number, words: NumberWords): NumberMark[] => {
+/**
+ * A number set off by a space from a word that only begins with a counter: 三, a space, 人事委員会 is the item number 三 of a list,
+ * not 三人. The tokenizer reads 人事 as one word there and 人 alone in 3 人が来た.
+ */
+const isBeforeLongerWord = (numeral: string, written: string, offset: number, tokens: readonly Token[]): boolean => {
+  const counter = written.slice(numeral.length).trimStart();
+  if (counter.length === written.length - numeral.length) return false;
+  const word = tokens.find((token) => token.span.start === offset + written.length - counter.length);
+  return word !== undefined && word.surface.length > counter.length;
+};
+
+const countMarks = (text: string, base: number, words: NumberWords, tokens: readonly Token[]): NumberMark[] => {
   const pattern = countPattern(words);
   if (pattern === undefined) return [];
   return [...text.matchAll(pattern)].flatMap((match): NumberMark[] => {
     const [written, digits, kanji] = match;
     if (kanji !== undefined && isIdiomNumeral(kanji)) return [];
+    if (isBeforeLongerWord(digits ?? kanji ?? "", written, base + match.index, tokens)) return [];
     return [{ kind: "count", style: digits === undefined ? "kanji" : "digits", written, offset: base + match.index }];
   });
 };
@@ -176,7 +188,7 @@ const englishCountMarks = (sentence: Sentence, words: NumberWords): NumberMark[]
 export const numberMarksIn = (sentence: Sentence, words: NumberWords, language: string, source: string): NumberMark[] => {
   const base = sentence.span.start;
   const marks = [
-    ...countMarks(sentence.text, base, words),
+    ...countMarks(sentence.text, base, words, sentence.tokens ?? []),
     ...groupingMarks(sentence.text, base, words, source),
     ...percentMarks(sentence.text, base, words),
     ...(language === "ja" ? [] : englishCountMarks(sentence, words)),

package/src/detectors/number-unit.ts

@@ -6,6 +6,8 @@ import { readMarkdown } from "../markdown-read.ts";
 import { spanOf, type MarkdownNode } from "../markdown-node.ts";
 import { eachPreOrder } from "../tree-walk.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { formsOf } from "./currency-notation.ts";
+import { scaledFiguresIn, scaleGaps, type ScaleWords } from "./scaled-figure-unit.ts";
 
 /** One value of a kind: where its number starts, as written, and its unit ("" when bare). */
 export type Measured = { readonly kind: string; readonly name: string; readonly offset: number; readonly written: string; readonly unit: string };
@@ -157,7 +159,30 @@ const pieceCountOf = (doc: ProseDocument): PieceCount => {
   return { columns: patterns("column"), periods: patterns("period") };
 };
 
-export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] => {
+const patternsOf = (doc: ProseDocument, name: string): string[] => (doc.lexicons[name] ?? []).map((entry) => entry.pattern);
+
+const scaleWordsOf = (doc: ProseDocument): ScaleWords => ({
+  scales: patternsOf(doc, "figure-scale-word"),
+  forms: formsOf(doc),
+  joiners: ["figure-scale-joiner", "range-connector", "enumeration-joiner"].flatMap((name) => patternsOf(doc, name)),
+});
+
+/** The one number in prose with a word of scale and no unit, where that word otherwise always carries one (83,494百万). */
+const scaleFindings = (doc: ProseDocument): Finding[] => {
+  const prose = doc.prose ?? doc.source;
+  const words = scaleWordsOf(doc);
+  return scaleGaps(prose, scaledFiguresIn(prose, words), words.joiners).map(({ figure, unit }) => ({
+    rule: "number-without-unit",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    variant: "scale",
+    quote: quoteAt(doc.source, figure.offset),
+    values: { value: figure.written, name: figure.scale, unit, offset: figure.offset },
+  }));
+};
+
+const columnFindings = (doc: ProseDocument): Finding[] => {
   const count = pieceCountOf(doc);
   return unitGaps(measuredValues(doc.source, doc.prose ?? doc.source, unitsOf(doc)))
     .filter((gap) => !isPieceCount(gap, count))
@@ -170,3 +195,5 @@ export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] => {
       values: { value: gap.value.written, name: gap.value.name, unit: gap.unit, offset: gap.value.offset },
     }));
 };
+
+export const numberWithoutUnit: Detector = (doc: ProseDocument): Finding[] => [...columnFindings(doc), ...scaleFindings(doc)];

package/src/detectors/numeral-opener.ts

@@ -1,3 +1,4 @@
+import { escapeRegExp } from "../orthography.ts";
 import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
 
 /**
@@ -56,6 +57,31 @@ export const followsSentenceEnd = (source: string, offset: number, labels: Reado
   return DIGITS.test(word) || (PLAIN_WORD.test(word) && !labels.has(word.toLowerCase()));
 };
 
+const CLAUSE_NUMBER = /^(?<parent>\d{1,3})\.(?<child>\d{1,3})$/u;
+const BLANK = /^[ \t]*$/u;
+
+/** Whether offset is the first thing on its line, after spaces only. */
+const startsLine = (source: string, offset: number): boolean => BLANK.test(source.slice(source.lastIndexOf("\n", offset - 1) + 1, offset));
+
+/** Whether a line opens with this clause number (2.2) and a space. */
+const opensLine = (source: string, clause: string): boolean => new RegExp(String.raw`(?:^|\n)[ \t]*${escapeRegExp(clause)}[ \t]`, "u").test(source);
+
+/**
+ * A clause number that opens a numbered paragraph (2.1 the term starts on signing.), not a figure: it opens a line, and a
+ * clause next to it in the same numbering (2.0 or 2.2) opens a line too. A figure at a line's start (2.5 million units
+ * were sold.) has no such neighbour.
+ */
+export const opensNumberedParagraph = (source: string, offset: number, numeral: string): boolean => {
+  const clause = CLAUSE_NUMBER.exec(numeral)?.groups;
+  if (clause === undefined || !startsLine(source, offset)) return false;
+  const child = clause["child"] ?? "";
+  // 3.10 sits next to 3.9 or, numbered with a zero, 3.09.
+  const neighbours = [Number(child) - 1, Number(child) + 1]
+    .filter((neighbour) => neighbour >= 0)
+    .flatMap((neighbour) => [String(neighbour), String(neighbour).padStart(child.length, "0")]);
+  return neighbours.some((neighbour) => opensLine(source, `${clause["parent"] ?? ""}.${neighbour}`));
+};
+
 const inside = (spans: readonly Span[], offset: number): boolean => spans.some((span) => span.start <= offset && offset < span.end);
 
 const leadingSpace = (sentence: Sentence): number => sentence.text.length - sentence.text.trimStart().length;
@@ -66,7 +92,7 @@ export const numeralOpener: Detector = (doc): Finding[] => {
     const offset = sentence.span.start + leadingSpace(sentence);
     if (sentence.embeddedLanguage !== undefined || inside(doc.listSpans, offset)) return [];
     const numeral = openingNumeral(sentence.text);
-    if (numeral === undefined || !followsSentenceEnd(doc.source, offset, labels)) return [];
+    if (numeral === undefined || !followsSentenceEnd(doc.source, offset, labels) || opensNumberedParagraph(doc.source, offset, numeral)) return [];
     return [{ rule: "", severity: "warning", line: 0, column: 0, quote: sentence.text.trim(), values: { numeral, offset } }];
   });
 };

package/src/detectors/numeral-word.ts

@@ -0,0 +1,33 @@
+/**
+ * 大文字の並びでも略語として書かれないもの。どれも字の形だけで決まる。
+ * - I だけのローマ数字（II、III）。名前の後ろでなくても番号で（Doswell, III、1964: II Structure）、この形の略語は使われない。
+ *   IV や VI のように V・X を含む数字は略語（静脈注射の IV）でもあるので、名前の番号（name-numeral.ts）の位置でだけ外す。
+ * - 大文字で始まる語に - で繋いだ I・V・X の数字（Association-IV）。名前の番号を空白でなく - で書いた形。
+ * - X を 3 つ以上並べた伏せ字（the Secretary of State for XXX）や X の数で書く染色体の型（XXX症候群）。KKK や WWW のような他の字の繰り返しは略語のまま数える。
+ */
+
+type Span = { readonly start: number; readonly end: number };
+
+// 略語の切り出しと同じ境目。日本語の文字（XXX症候群）は語の続きではない。
+const NOT_BEFORE = String.raw`(?<![A-Za-z0-9_&])`;
+const NOT_AFTER = String.raw`(?![A-Za-z0-9_&])`;
+
+const ONES_NUMERAL = new RegExp(`${NOT_BEFORE}I{2,3}${NOT_AFTER}`, "gu");
+const MASK = new RegExp(`${NOT_BEFORE}X{3,}${NOT_AFTER}`, "gu");
+const SMALL_NUMERAL = "(?=[IVX])X{0,3}(?:IX|IV|V?I{0,3})";
+const JOINED_NUMERAL = new RegExp(String.raw`(?<![A-Za-z0-9_-])\p{Lu}\p{Ll}+-(?<numeral>${SMALL_NUMERAL})${NOT_AFTER}`, "gu");
+
+const spanOf = (match: RegExpExecArray): Span => ({ start: match.index, end: match.index + match[0].length });
+
+const joinedSpans = (text: string): Span[] =>
+  [...text.matchAll(JOINED_NUMERAL)].map((match) => {
+    const end = match.index + match[0].length;
+    return { start: end - (match.groups?.["numeral"] ?? "").length, end };
+  });
+
+/** 文の中の、番号か伏せ字と読む大文字の範囲。 */
+export const numeralWordSpans = (text: string): Span[] => [
+  ...[...text.matchAll(ONES_NUMERAL)].map(spanOf),
+  ...[...text.matchAll(MASK)].map(spanOf),
+  ...joinedSpans(text),
+];

package/src/detectors/obligation-without-deadline.ts

@@ -6,14 +6,19 @@
 // duty-marker (shall, will), duty-ending (う, するものとする: what may follow a Japanese act at the sentence end),
 // stated-deadline (by the, までに) with concrete-deadline and vague-deadline, deadline-permission and currency-notation. Pure.
 import { quoteAt } from "./structure-tree.ts";
+import { actsTimedAt, type NamedDeadline, type Units } from "./deadline-unit.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { grantsRight, statesConcrete, vagueIn } from "./vague-deadline.ts";
 import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
 
 export type UntimedDuty = { readonly offset: number; readonly act: string };
 
-/** sameLine: the sentence goes on the line of the one before it (no line break between them). */
-type Text = { readonly start: number; readonly text: string; readonly sameLine?: boolean };
+/**
+ * sameLine: the sentence goes on the line of the one before it (no line break between them). timedActs: the acts whose
+ * dated deadline (支払期日 for 支払) its article, else its list or paragraph, names; a duty to do one of them is timed.
+ */
+type Text = { readonly start: number; readonly text: string; readonly sameLine?: boolean; readonly timedActs?: readonly string[] };
 
 /** What the word lists give the decision. */
 export type DutyWords = {
@@ -155,6 +160,7 @@ export const untimedDuties = (texts: readonly Text[], words: DutyWords): Untimed
     if (grantsRight(text, words.permissions) || statesAmount(text.text, words.currencies)) return [];
     const act = actIn(text.text, words);
     if (act === undefined || (LATIN.test(act.act) && !isWordStart(text.text, act.at))) return [];
+    if (text.timedActs?.some((timed) => timed.toLowerCase() === act.act.toLowerCase()) === true) return [];
     return [{ offset: text.start + act.at, act: text.text.slice(act.at, act.at + act.act.length) }];
   });
   const limitedSentences = texts.filter((text) => statesLimit(text, words)).length;
@@ -163,12 +169,30 @@ export const untimedDuties = (texts: readonly Text[], words: DutyWords): Untimed
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
-export const obligationWithoutDeadline: Detector = (doc): Finding[] =>
-  untimedDuties(
+const unitsOf = (doc: ProseDocument): Units => ({
+  articles: doc.structure === undefined ? [] : inDocumentOrder(doc.structure).flatMap((node) => (node.kind === "article" ? [node.span] : [])),
+  lists: doc.lists.map((list) => list.span),
+  paragraphs: doc.paragraphs.map((paragraph) => paragraph.span),
+});
+
+/** The acts a sentence's unit names a dated deadline for (named-deadline: the name, and the act as its group). */
+const timedActsReader = (doc: ProseDocument): ((offset: number) => string[]) => {
+  const deadlines: NamedDeadline[] = (doc.lexicons["named-deadline"] ?? []).flatMap((entry) =>
+    entry.group === undefined ? [] : [{ name: entry.pattern, act: entry.group }],
+  );
+  if (deadlines.length === 0) return () => [];
+  const units = unitsOf(doc);
+  return (offset) => actsTimedAt(doc.source, units, offset, deadlines, phraseIn);
+};
+
+export const obligationWithoutDeadline: Detector = (doc): Finding[] => {
+  const timedActs = timedActsReader(doc);
+  return untimedDuties(
     doc.sentences.map((sentence, index) => ({
       start: sentence.span.start,
       text: sentence.text,
       sameLine: index > 0 && !doc.source.slice(doc.sentences[index - 1]?.span.end ?? 0, sentence.span.start).includes("\n"),
+      timedActs: timedActs(sentence.span.start),
     })),
     {
       acts: patternsOf(doc, "timed-duty"),
@@ -190,3 +214,4 @@ export const obligationWithoutDeadline: Detector = (doc): Finding[] =>
     quote: quoteAt(doc.source, duty.offset),
     values: { word: duty.act, offset: duty.offset },
   }));
+};

package/src/detectors/open-end-class.ts

@@ -0,0 +1,78 @@
+import type { LexiconEntry, Token } from "../plugin.ts";
+import type { TokenRange } from "./lexicon-match.ts";
+
+// An open-end word on a list of acts that gives examples of a kind of act named right after it: 印刷等、二次的に利用される
+// 場合 and 印刷等の二次的利用 say "secondary use, such as printing". The kind bounds the list, so it leaves nothing open.
+// A list followed by the manner of the act the requirement asks for (ログ等、具体的に保存すること) names no kind and stays
+// open. The link (、 の) and the suffix that makes a word name a kind (的) come from the language's requirement-open-end
+// lexicon. Pure.
+
+/** The lexicon groups: a link right after the open word, and a suffix that makes the noun after it name a kind. */
+const LINK = "class-link";
+const CLASS_SUFFIX = "class-suffix";
+const NAME_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+/** The tagger's mark of a noun that names an act (印刷, 利用: a verbal noun). */
+const ACT_NOUN = "Vnoun";
+const PUNCT = "PUNCT";
+/** The parts of speech a phrase about the act ends in before its comma (場合、 には、). */
+const PHRASE_END_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADP"]);
+/** How many tokens may stand between the suffix and the act it qualifies (二次的に利用: に). */
+const SUFFIX_REACH = 2;
+
+export type ClassWords = { readonly links: ReadonlySet<string>; readonly suffixes: ReadonlySet<string> };
+
+const patternsIn = (entries: readonly LexiconEntry[], group: string): ReadonlySet<string> =>
+  new Set(entries.filter((entry) => entry.group === group).map((entry) => entry.pattern));
+
+export const classWordsOf = (entries: readonly LexiconEntry[]): ClassWords => ({
+  links: patternsIn(entries, LINK),
+  suffixes: patternsIn(entries, CLASS_SUFFIX),
+});
+
+/** Whether an entry is one of the class cues rather than an open-end word. */
+export const isClassCue = (entry: LexiconEntry): boolean => entry.group === LINK || entry.group === CLASS_SUFFIX;
+
+const isActNoun = (token: Token | undefined): boolean => token !== undefined && token.features?.VerbForm === ACT_NOUN;
+
+const attached = (left: Token | undefined, right: Token | undefined): boolean =>
+  left !== undefined && right !== undefined && left.span.end === right.span.start;
+
+/** The index of the last noun written one after another from index on, or index - 1 when no noun stands there. */
+const nounRunEnd = (tokens: readonly Token[], index: number): number => {
+  const token = tokens[index];
+  if (token === undefined || !NAME_POS.has(token.pos)) return index - 1;
+  return attached(token, tokens[index + 1]) ? nounRunEnd(tokens, index + 1) : index;
+};
+
+/**
+ * Whether the act at index heads a phrase the requirement is about (利用される場合、 二次的利用には、): its clause ends in
+ * a noun or a particle before a comma inside the sentence. An act whose clause runs to the end of the sentence, or ends
+ * in a verb (保存すること。 保存し、), is what the requirement asks for, and the list before it stays open.
+ */
+const headsPhrase = (tokens: readonly Token[], index: number): boolean => {
+  const comma = tokens.findIndex((token, at) => at > index && token.pos === PUNCT);
+  const last = tokens[comma - 1];
+  const goesOn = tokens.slice(comma + 1).some((token) => token.pos !== PUNCT && token.surface.trim() !== "");
+  return comma !== -1 && goesOn && last !== undefined && PHRASE_END_POS.has(last.pos);
+};
+
+/** Whether the noun run that starts at index holds a class suffix (二次的, 営利的) and an act that heads a phrase follows within reach. */
+const kindOfActAt = (tokens: readonly Token[], index: number, words: ClassWords): boolean => {
+  const end = nounRunEnd(tokens, index);
+  const suffix = tokens.slice(index + 1, end + 1).findIndex((token) => words.suffixes.has(token.surface));
+  if (suffix === -1) return false;
+  const afterSuffix = index + 1 + suffix + 1;
+  const act = tokens.slice(afterSuffix, afterSuffix + SUFFIX_REACH).findIndex((token) => isActNoun(token));
+  return act !== -1 && headsPhrase(tokens, afterSuffix + act);
+};
+
+/**
+ * Whether the open word ends a list of acts that gives examples of a kind of act named right after it: the item before
+ * the word is an act (印刷), a link follows (、 の), then a noun built with a class suffix (二次的) and an act (利用).
+ * range: the tokens the open word covers.
+ */
+export const namesClassAfter = (tokens: readonly Token[], range: TokenRange, words: ClassWords): boolean => {
+  const link = tokens[range.end];
+  if (!isActNoun(tokens[range.start - 1]) || link === undefined || !words.links.has(link.surface)) return false;
+  return kindOfActAt(tokens, range.end + 1, words);
+};

package/src/detectors/open-end-condition.ts

@@ -0,0 +1,40 @@
+import type { Sentence } from "../plugin.ts";
+
+// An open list inside brackets that gloss a condition (必要ない場合（単一テーブルへの SELECT 等）も付与すること): the list
+// gives examples of when the duty applies, not what the duty covers, so leaving it open is no smell. The condition words
+// come from the language's requirement-open-condition lexicon. Pure.
+
+/** Each closing bracket and the opening bracket it closes. */
+const PAIRS: ReadonlyMap<string, string> = new Map([
+  [")", "("],
+  ["）", "（"],
+]);
+const OPENING: ReadonlySet<string> = new Set(PAIRS.values());
+
+type Open = { readonly char: string; readonly index: number };
+
+/**
+ * The brackets still open before `end` of `text`, outermost first. A closing bracket closes only its own kind, so a
+ * stray half-width ")" leaves a full-width "（" open. One pass, no recursion: a statute's sentence is long.
+ */
+const openBracketsBefore = (text: string, end: number): Open[] => {
+  const open: Open[] = [];
+  text
+    .slice(0, Math.max(0, end))
+    .split("")
+    .forEach((char, index) => {
+      if (OPENING.has(char)) open.push({ char, index });
+      else if (PAIRS.has(char) && open.at(-1)?.char === PAIRS.get(char)) open.pop();
+    });
+  return open;
+};
+
+/**
+ * Whether the open word starting at document offset `start` stands inside brackets, at any depth, that open right after
+ * a condition word (場合（…等）, とき（…など）, 場合（A（B 等））).
+ */
+export const glossesCondition = (sentence: Sentence, start: number, conditions: readonly string[]): boolean =>
+  openBracketsBefore(sentence.text, start - sentence.span.start).some((bracket) => {
+    const before = sentence.text.slice(0, bracket.index).trimEnd();
+    return conditions.some((word) => word !== "" && before.endsWith(word));
+  });

package/src/detectors/open-end-names.ts

@@ -135,6 +135,12 @@ const isNamed = (source: string, occurrence: Occurrence, names: OpenEndNames): b
   inQuotedName(source, occurrence, names.quoted) ||
   partsHoldingWord(source, occurrence).some((part) => names.defined.has(part) || names.heads.some((head) => head.startsWith(part)));
 
-/** Where the word first stands outside a name the document gives (its document offset), or undefined when it never does. */
-export const openEndAt = (doc: ProseDocument, sentence: Sentence, word: LexiconEntry, names: OpenEndNames): number | undefined =>
-  occurrencesIn(sentence, word).find((occurrence) => !isNamed(doc.source, occurrence, names))?.start;
+/** Whether the words around an occurrence bound its list; range: the tokens the word covers. */
+export type BoundedAfter = (tokens: readonly Token[], range: TokenRange) => boolean;
+
+/**
+ * Where the word first stands outside a name the document gives and is not bounded by the words after it (its document
+ * offset), or undefined when it never does.
+ */
+export const openEndAt = (doc: ProseDocument, sentence: Sentence, word: LexiconEntry, names: OpenEndNames, boundedAfter: BoundedAfter): number | undefined =>
+  occurrencesIn(sentence, word).find((occurrence) => !isNamed(doc.source, occurrence, names) && !boundedAfter(occurrence.tokens, occurrence.range))?.start;

package/src/detectors/open-end-question.ts

@@ -0,0 +1,50 @@
+import type { LexiconEntry, Sentence } from "../plugin.ts";
+
+// An open list right before a question that asks the reader to choose (…措置など、どのような措置を求めるのかを記載する):
+// the list gives example answers, and leaving it open is the point. The question's words come from the language's
+// requirement-open-question lexicon. Pure.
+
+const INTERROGATIVE = "interrogative";
+const QUESTION_END = "question-end";
+/** Words that start like an interrogative and ask how instead (どのように), which offers no list of answers. */
+const NOT_INTERROGATIVE = "not-interrogative";
+/** A particle that turns the interrogative into "any" (どの部署でも, 何をも): no question follows. */
+const UNIVERSAL_MARK = "universal-mark";
+/** The marks that may stand between the list's last word and the question (、). */
+const LINK = /^[\s、，,]*/u;
+const PARTICLE = "PART";
+
+export type QuestionWords = {
+  readonly interrogatives: readonly string[];
+  readonly notInterrogatives: readonly string[];
+  readonly ends: ReadonlySet<string>;
+  readonly universalMarks: ReadonlySet<string>;
+};
+
+const patternsIn = (entries: readonly LexiconEntry[], group: string): string[] =>
+  entries.filter((entry) => entry.group === group && entry.pattern !== "").map((entry) => entry.pattern);
+
+export const questionWordsOf = (entries: readonly LexiconEntry[]): QuestionWords => ({
+  interrogatives: patternsIn(entries, INTERROGATIVE),
+  notInterrogatives: patternsIn(entries, NOT_INTERROGATIVE),
+  ends: new Set(patternsIn(entries, QUESTION_END)),
+  universalMarks: new Set(patternsIn(entries, UNIVERSAL_MARK)),
+});
+
+/**
+ * Whether a question starts right after the open word that ends at document offset end, and closes later in the
+ * sentence with a question particle, before any particle that makes the interrogative mean "any" (どの部署でも): the list
+ * before the word gives examples of what the question asks for.
+ */
+export const asksAfter = (sentence: Sentence, end: number, words: QuestionWords): boolean => {
+  const rest = sentence.text.slice(end - sentence.span.start);
+  const link = LINK.exec(rest)?.[0].length ?? 0;
+  const question = rest.slice(link);
+  const startsWithAny = (patterns: readonly string[]): boolean => patterns.some((word) => question.startsWith(word));
+  const asks = startsWithAny(words.interrogatives) && !startsWithAny(words.notInterrogatives);
+  const questionStart = end + link;
+  const after = (sentence.tokens ?? []).filter((token) => token.span.start >= questionStart);
+  const close = after.findIndex((token) => token.pos === PARTICLE && words.ends.has(token.surface));
+  const universal = after.slice(0, close).some((token) => words.universalMarks.has(token.surface));
+  return asks && close !== -1 && !universal;
+};

package/src/detectors/open-end-scope.ts

@@ -0,0 +1,62 @@
+import type { LexiconEntry, Token } from "../plugin.ts";
+import { entryEndsAt, type TokenRange } from "./lexicon-match.ts";
+
+// An open-end word in a requirement is a smell only when its list is part of what the reader is asked to do (ログ等を保存
+// すること): the reader cannot tell when the duty is met. A list in the condition the duty depends on (訂正等を行った際に、
+// 通知する), in a right the writer grants (投稿データ等を消去できるものとします), or in what is forbidden or excluded
+// (複製、転載等をしてはならない, 事情などにより責任を負わないものとします) is left open on purpose, and is the usual way a
+// contract is drafted. The words that tell the four apart come from the language's requirement-open-end lexicon, in the
+// groups below. Pure.
+
+/** The lexicon groups, in the order a tie at one token is decided: a duty word wins over the words that open a list on purpose. */
+const DUTY = "scope-duty";
+const ON_PURPOSE = ["scope-permission", "scope-prohibition"] as const;
+const CONDITION = "scope-condition";
+const SCOPE_GROUPS: ReadonlySet<string> = new Set([DUTY, CONDITION, ...ON_PURPOSE]);
+
+/** The parts of speech that end a clause with its own predicate before a comma (消去し、 行い、). */
+const PREDICATE_POS: ReadonlySet<string> = new Set(["VERB", "AUX", "ADJ"]);
+const PUNCT = "PUNCT";
+
+export type ScopeWords = { readonly duty: readonly LexiconEntry[]; readonly onPurpose: readonly LexiconEntry[]; readonly condition: readonly LexiconEntry[] };
+
+const inGroup = (entries: readonly LexiconEntry[], groups: readonly string[]): LexiconEntry[] => entries.filter((entry) => groups.includes(entry.group ?? ""));
+
+export const scopeWordsOf = (entries: readonly LexiconEntry[]): ScopeWords => ({
+  duty: inGroup(entries, [DUTY]),
+  onPurpose: inGroup(entries, ON_PURPOSE),
+  condition: inGroup(entries, [CONDITION]),
+});
+
+/** Whether an entry is one of the scope cues rather than an open-end word. */
+export const isScopeCue = (entry: LexiconEntry): boolean => SCOPE_GROUPS.has(entry.group ?? "");
+
+const startsAt = (tokens: readonly Token[], entries: readonly LexiconEntry[], index: number): boolean =>
+  entries.some((entry) => entryEndsAt(tokens, entry, index + (entry.tokens?.length ?? 0)));
+
+/** A comma right after a predicate closes the clause the list stands in (消去し、). */
+const closesClause = (tokens: readonly Token[], index: number): boolean => tokens[index]?.pos === PUNCT && PREDICATE_POS.has(tokens[index - 1]?.pos ?? "");
+
+/** A condition word that closes a clause about an act (行った際, 判断される場合): it follows a predicate. */
+const conditionAt = (tokens: readonly Token[], index: number, words: ScopeWords): boolean =>
+  PREDICATE_POS.has(tokens[index - 1]?.pos ?? "") && startsAt(tokens, words.condition, index);
+
+type Scope = "duty" | "on-purpose" | undefined;
+
+/**
+ * What the list belongs to: the first duty, permission or prohibition word after it, or a condition word before the
+ * clause the list stands in closes. undefined when none follows (the sentence's own ending decides: こと。).
+ */
+const scopeFrom = (tokens: readonly Token[], index: number, words: ScopeWords, inClause: boolean): Scope => {
+  if (index >= tokens.length) return undefined;
+  if (startsAt(tokens, words.duty, index)) return "duty";
+  if (startsAt(tokens, words.onPurpose, index) || (inClause && conditionAt(tokens, index, words))) return "on-purpose";
+  return scopeFrom(tokens, index + 1, words, inClause && !closesClause(tokens, index));
+};
+
+/**
+ * Whether the open word at range ends a list that is open on purpose: a condition, a permission or a prohibition holds
+ * it, not the duty the requirement states. range: the tokens the open word covers.
+ */
+export const openOnPurpose = (tokens: readonly Token[], range: TokenRange, words: ScopeWords): boolean =>
+  scopeFrom(tokens, range.end, words, true) === "on-purpose";