chaffjs 0.34.0 → 0.36.0

package/src/detectors/parallel-definition.ts

@@ -0,0 +1,64 @@
+import type { Lexicon, Sentence, Token } from "../plugin.ts";
+
+// 並べた定義: どの文も違う語を、同じ型（〜を指します、〜といいます）で定義する。同じ文末が続くのは型をそろえたからで、
+// 書き手の調子の繰り返しではない。
+
+const TRAILING_POS: ReadonlySet<string> = new Set(["PUNCT", "SYM"]);
+const TAIL_POS: ReadonlySet<string> = new Set(["AUX", "PART"]);
+
+export type DefinitionWords = { readonly frames: ReadonlySet<string>; readonly topics: ReadonlySet<string> };
+
+const patternsOf = (lexicon: Lexicon | undefined, group: string): ReadonlySet<string> =>
+  new Set((lexicon ?? []).filter((entry) => entry.group === group).map((entry) => entry.pattern));
+
+export const definitionWordsOf = (lexicon: Lexicon | undefined): DefinitionWords => ({
+  frames: patternsOf(lexicon, "frame"),
+  topics: patternsOf(lexicon, "topic"),
+});
+
+const surfacesOf = (tokens: readonly Token[]): string => tokens.map((token) => token.surface).join("");
+
+/** 述語（文末の助動詞の前の語）の位置。助動詞で終わらない文には無い。 */
+const predicateAt = (tokens: readonly Token[]): number | undefined => {
+  const last = tokens.findLastIndex((token) => !TRAILING_POS.has(token.pos));
+  const head = tokens.slice(0, last + 1).findLastIndex((token) => !TAIL_POS.has(token.pos));
+  return head > 0 && head < last ? head : undefined;
+};
+
+const PARTICLE_POS = "ADP";
+const TERM_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
+
+/** 定義の文が定義する語と、その型（を指す）。 */
+export type Definition = { readonly term: string; readonly frame: string };
+
+/** topic の助詞（は）より前。無ければ、述語の前の助詞の直前の名詞（〜を台風といいます の 台風）。 */
+const termOf = (tokens: readonly Token[], head: number, words: DefinitionWords): string => {
+  const topic = tokens.slice(0, head - 1).findIndex((token) => token.pos === PARTICLE_POS && words.topics.has(token.surface));
+  if (topic > 0) return surfacesOf(tokens.slice(0, topic));
+  const before = tokens[head - 2];
+  return before !== undefined && TERM_POS.has(before.pos) ? before.surface : "";
+};
+
+/** その文が定義する語と型。型の文（を指す、という）でなければ無い。 */
+export const definitionOf = (sentence: Sentence, words: DefinitionWords): Definition | undefined => {
+  const tokens = (sentence.tokens ?? []).filter((token) => token.surface.trim() !== "");
+  const head = predicateAt(tokens);
+  const particle = head === undefined ? undefined : tokens[head - 1];
+  const predicate = head === undefined ? undefined : tokens[head];
+  if (head === undefined || particle === undefined || predicate === undefined) return undefined;
+  const frame = `${particle.surface}${predicate.lemma ?? predicate.surface}`;
+  if (!words.frames.has(frame)) return undefined;
+  const term = termOf(tokens, head, words);
+  return term === "" ? undefined : { term, frame };
+};
+
+const isDefinition = (definition: Definition | undefined): definition is Definition => definition !== undefined;
+
+/** どの文も同じ型の定義で、定義する語がみな違う。 */
+export const isParallelDefinition = (sentences: readonly Sentence[], words: DefinitionWords): boolean => {
+  const definitions = sentences.map((sentence) => definitionOf(sentence, words));
+  if (!definitions.every(isDefinition)) return false;
+  const terms = new Set(definitions.map((definition) => definition.term));
+  const frames = new Set(definitions.map((definition) => definition.frame));
+  return terms.size === definitions.length && frames.size === 1;
+};

package/src/detectors/person-consistency.ts

@@ -1,5 +1,5 @@
 import type { Detector, Finding, ProseDocument, Sentence } from "../plugin.ts";
-import { personMentions, personMinorities, type PersonMention, type PersonWords } from "../person-forms.ts";
+import { personMentions, personMinorities, withoutOtherSenses, type PersonMention, type PersonWords } from "../person-forms.ts";
 
 const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords => ({
   words,
@@ -9,14 +9,16 @@ const wordsOf = (doc: ProseDocument, words: PersonWords["words"]): PersonWords =
 
 /**
  * One document naming itself (私たち / 弊社, 私 / 筆者) or its reader (you / one) two ways: the minority form of each slot.
- * Sentences in another language than the document's are left out; quotations are left out by personMentions.
+ * Sentences in another language than the document's are left out; quotations are left out by personMentions. A form the
+ * language package lists in person-other-sense (本社, also the head office) counts only where it is the usual form.
  */
 export const personMix: Detector = (doc, options): Finding[] => {
   const person = wordsOf(doc, options.lexicon ?? []);
   const entries: { readonly sentence: Sentence; readonly mention: PersonMention }[] = doc.sentences
     .filter((sentence) => sentence.embeddedLanguage === undefined)
     .flatMap((sentence) => personMentions(sentence.text, person).map((mention) => ({ sentence, mention })));
-  return personMinorities(entries, options.limit).flatMap(({ odd, usual, of }) =>
+  const otherSenses = new Set((doc.lexicons["person-other-sense"] ?? []).map((entry) => entry.pattern));
+  return personMinorities(withoutOtherSenses(entries, otherSenses), options.limit).flatMap(({ odd, usual, of }) =>
     odd.map(({ sentence, mention }) => ({
       rule: "",
       severity: "info" as const,

package/src/detectors/phrase-match.ts

@@ -1,5 +1,6 @@
-import type { Detector, DetectorOptions, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryEnds, entryIn } from "./lexicon-match.ts";
+import { mentionCuesOf, onlyMentioned } from "./mentioned-phrase.ts";
 import { closingSentences } from "../closing-paragraph.ts";
 
 /** 冒頭は先頭 2 段落ぶん。「どの記事にも当てはまる書き出し」は冒頭にあるときだけ問題。 */
@@ -17,9 +18,12 @@ const inScope = (doc: ProseDocument, where: string | undefined): readonly Senten
 
 type Hit = { readonly sentence: Sentence; readonly matched: string };
 
-const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon): Hit[] =>
+/** Whether the entry's words in the sentence count as a use. phrase-match counts every one. */
+type IsUsed = (sentence: Sentence, entry: LexiconEntry) => boolean;
+
+const hitsIn = (sentences: readonly Sentence[], lexicon: Lexicon, isUsed: IsUsed = () => true): Hit[] =>
   sentences.flatMap((sentence) => {
-    const matched = lexicon.find((entry) => entryIn(sentence, entry));
+    const matched = lexicon.find((entry) => entryIn(sentence, entry) && isUsed(sentence, entry));
     return matched === undefined ? [] : [{ sentence, matched: matched.pattern }];
   });
 
@@ -33,9 +37,9 @@ const findingsOf = (hits: readonly Hit[], limit: number, count = hits.length): F
     values: { matched: hit.matched, count, limit, offset: hit.sentence.span.start },
   }));
 
-const phraseHits = (doc: ProseDocument, options: DetectorOptions): Hit[] => {
+const phraseHits = (doc: ProseDocument, options: DetectorOptions, isUsed?: IsUsed): Hit[] => {
   const lexicon = options.lexicon ?? [];
-  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon);
+  return lexicon.length === 0 ? [] : hitsIn(inScope(doc, options.where), lexicon, isUsed);
 };
 
 /**
@@ -47,6 +51,13 @@ export const phraseMatch: Detector = (doc, options): Finding[] => {
   return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
 };
 
+/** phrase-match の、言葉として名指しただけの言い回し（the phrase "…", 「…」という言い方）を数えない版（mentioned-phrase.ts）。 */
+export const phraseInUse: Detector = (doc, options): Finding[] => {
+  const cues = mentionCuesOf(doc.lexicons["mention-cue"] ?? []);
+  const hits = phraseHits(doc, options, (sentence, entry) => !onlyMentioned(sentence, entry, cues));
+  return hits.length < options.limit ? [] : findingsOf(hits, options.limit);
+};
+
 type Uses = { readonly sentence: Sentence; readonly matched: string; readonly count: number };
 
 /**

package/src/detectors/placeholder-text.ts

@@ -29,6 +29,7 @@ const withoutClosers = (text: string): string => {
 /** Lexicon groups of placeholder-word. An entry without a group is a word written inside a template's brackets. */
 const MARKER = "marker";
 const INSTRUCTION = "instruction";
+const LABEL = "label";
 
 const innerOf = (match: RegExpExecArray): string => (match[1] ?? match[2] ?? match[3] ?? "").trim().toLowerCase();
 
@@ -64,11 +65,24 @@ const markerSpans = (text: string, markers: Lexicon): Span[] => {
   return [{ start, end: start + withoutClosers(rest).length }];
 };
 
+/**
+ * A template's instruction label left in the text ("OPTIONAL: General conclusions"): the label exactly as the lexicon
+ * writes it, in capitals, opening the line before a colon and some text. "Optional: bring a jacket" is a note, not a label.
+ */
+const labelSpans = (line: string, labels: Lexicon): Span[] => {
+  const start = OPENING.exec(line)?.[0].length ?? 0;
+  const rest = line.slice(start);
+  const label = labels.find((entry) => rest.startsWith(entry.pattern));
+  if (label === undefined) return [];
+  const after = rest.slice(label.pattern.length);
+  return COLON_NEXT.test(after) && withoutClosers(after.replace(COLON_NEXT, "")) !== "" ? [{ start, end: start + rest.trimEnd().length }] : [];
+};
+
 /** Each line of a sentence on its own: values a line apart ("TBD: owner" then "TBD: date") are two blanks, not one. */
-const lineMarkerSpans = (text: string, markers: Lexicon): Span[] =>
+const lineMarkerSpans = (text: string, markers: Lexicon, labels: Lexicon): Span[] =>
   text.split("\n").flatMap((line, index, lines) => {
     const offset = lines.slice(0, index).reduce((sum, previous) => sum + previous.length + 1, 0);
-    return markerSpans(line, markers).map((span) => ({ start: span.start + offset, end: span.end + offset }));
+    return [...markerSpans(line, markers), ...labelSpans(line, labels)].map((span) => ({ start: span.start + offset, end: span.end + offset }));
   });
 
 /** 文の中の、埋め忘れた雛形の空欄（[Your Name]、【会社名】、（ここに会社名を書く）、TBD: …）の範囲。words は placeholder-word の語彙表。 */
@@ -76,9 +90,10 @@ export const placeholderSpans = (text: string, words: Lexicon): Span[] => {
   const bracketWords = words.filter((word) => word.group === undefined);
   const instructions = words.filter((word) => word.group === INSTRUCTION);
   const markers = words.filter((word) => word.group === MARKER);
+  const labels = words.filter((word) => word.group === LABEL);
   return [
     ...bracketedSpans(text, BRACKETED, (inner) => holdsWord(inner, bracketWords)),
     ...(instructions.length === 0 ? [] : bracketedSpans(text, PARENTHESIZED, (inner) => opensWith(inner, instructions))),
-    ...lineMarkerSpans(text, markers),
+    ...lineMarkerSpans(text, markers, labels),
   ].toSorted((left, right) => left.start - right.start);
 };

package/src/detectors/placeholder.ts

@@ -5,6 +5,8 @@ import { escapeRegExp } from "../orthography.ts";
  * 定型文の書式で、略語ではない。繰り返しの語が、日付・時刻の単位の語（年、月、日）の前にあるか、
  * 区切り（/、:、-、.）で別の繰り返しの語か数字と繋がっているときだけ認める。単位の語は言語パッケージの語彙表から読む。
  * AI時代の AI や CI/CD の CD は、同じ文字の繰り返しではないので略語のまま数える。
+ * 単位の前には空白 1 つを挟んでもよい（XX 月 XX 日）。ひな形が名前の代わりに書く O か X を 4 つ以上並べた語（OOOO、XXXX）も、
+ * 単位が無くても略語ではない。3 つまで（AAA、XXX）は略語にもあり、ほかの文字の繰り返し（IIII、MMMMM）は崩れたローマ数字にもある。
  */
 
 type Span = { readonly start: number; readonly end: number };
@@ -14,6 +16,7 @@ const PART = String.raw`(?:[A-Z]{2,}|\d+)`;
 const SEPARATOR = "[/／:：.-]";
 const JOINED = new RegExp(String.raw`(?<![A-Za-z0-9_&])${PART}(?:${SEPARATOR}${PART})+(?![A-Za-z0-9_&])`, "gu");
 const CAPITALS = /[A-Z]+/gu;
+const LONG_REPEAT = /(?<![A-Za-z0-9_&])(?<letter>[OX])\k<letter>{3,}(?![A-Za-z0-9_&])/gu;
 
 const isRepeated = (word: string): boolean => REPEATED.test(word);
 
@@ -30,9 +33,13 @@ const joinedSpans = (text: string): Span[] =>
 
 const beforeUnitSpans = (text: string, units: readonly string[]): Span[] => {
   if (units.length === 0) return [];
-  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_&])[A-Z]{2,}(?=${units.map(escapeRegExp).join("|")})`, "gu");
+  const pattern = new RegExp(String.raw`(?<![A-Za-z0-9_&])[A-Z]{2,}(?= ?(?:${units.map(escapeRegExp).join("|")}))`, "gu");
   return [...text.matchAll(pattern)].filter((match) => isRepeated(match[0])).map(spanOf);
 };
 
-/** 文の中の、日付・時刻の書式に置いた大文字の範囲。units は日付・時刻の単位の語。 */
-export const placeholderSpans = (text: string, units: readonly string[]): Span[] => [...joinedSpans(text), ...beforeUnitSpans(text, units)];
+/** 文の中の、日付・時刻の書式とひな形の名前に置いた大文字の範囲。units は日付・時刻の単位の語。 */
+export const placeholderSpans = (text: string, units: readonly string[]): Span[] => [
+  ...joinedSpans(text),
+  ...beforeUnitSpans(text, units),
+  ...[...text.matchAll(LONG_REPEAT)].map(spanOf),
+];

package/src/detectors/postcode-end.ts

@@ -0,0 +1,16 @@
+// A postal address closed by its postcode right before an and / or ("… Upper Street, Leeds LS1 4AB, or email us"). The
+// commas between the address's lines are the address's, not a list's. Pure.
+
+/** UK (LS1 4AB, TW9 4DU, EC1A 1BB), US state and ZIP (IL 62701, DC 20001-1234), Canada (K1A 0B1). */
+const POSTCODE = String.raw`(?:[A-Z]{1,2}\d[A-Z\d]? \d[A-Z]{2}|[A-Z]{2} \d{5}(?:-\d{4})?|[A-Z]\d[A-Z] \d[A-Z]\d)`;
+/**
+ * The place the postcode is written after: a town (Leeds, Springfield,) or a province's code (ON). A code after a
+ * lower-case word ("model X1 4AB") is a product's, not an address's.
+ */
+const PLACE = String.raw`(?<![\w-])(?:[A-Z][a-z]+|[A-Z]{2}),? `;
+const POSTCODE_BEFORE = new RegExp(String.raw`${PLACE}${POSTCODE},?[ \t]*$`, "u");
+/** How far back the place may start: a long town name, the longest postcode and its comma, with room for spacing. */
+const REACH = 48;
+
+/** Whether the text before offset ends with a place and its postcode, the comma after it allowed. */
+export const followsPostcode = (source: string, offset: number): boolean => POSTCODE_BEFORE.test(source.slice(Math.max(0, offset - REACH), offset));

package/src/detectors/prose-total-words.ts

@@ -0,0 +1,18 @@
+import type { ProseDocument } from "../plugin.ts";
+import type { TotalWords } from "../structure/prose-total.ts";
+
+const patternsOf = (doc: ProseDocument, id: string, group?: string): string[] =>
+  (doc.lexicons[id] ?? []).filter((entry) => group === undefined || entry.group === group).map((entry) => entry.pattern);
+
+/** total-mismatch が文の中の合計と内訳を読む語。言語パッケージの語彙表から取る。 */
+export const proseTotalWordsOf = (doc: ProseDocument): TotalWords => ({
+  totals: patternsOf(doc, "total-phrase"),
+  breakdowns: patternsOf(doc, "breakdown-phrase"),
+  discounts: patternsOf(doc, "discount-word"),
+  joiners: patternsOf(doc, "breakdown-gap-joiner"),
+  leads: patternsOf(doc, "total-breakdown-lead"),
+  partials: patternsOf(doc, "breakdown-partial-word"),
+  mainOnly: patternsOf(doc, "breakdown-partial-word", "main"),
+  backReferences: patternsOf(doc, "total-back-reference"),
+  roundedUnits: patternsOf(doc, "rounded-amount-unit"),
+});

package/src/detectors/reference-text.ts

@@ -17,6 +17,7 @@ const inputOf = (doc: ProseDocument): ReferenceInput | undefined => {
       asides: patternsOf(doc, "reference-aside"),
       topicLinks: patternsOf(doc, "reference-topic-link"),
       vagueTopics: patternsOf(doc, "reference-topic-vague"),
+      listJoints: patternsOf(doc, "reference-list-joint"),
     },
   };
 };

package/src/detectors/registry/kanji-compound-slip.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { kanjiCompoundSlip } from "../kanji-compound-slip.ts";
+
+export const detector: Detector = kanjiCompoundSlip;

package/src/detectors/registry/phrase-in-use.ts

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

package/src/detectors/registry/unfilled-placeholder.ts

@@ -1,4 +1,4 @@
 import type { Detector } from "../../plugin.ts";
-import { unfilledPlaceholder } from "../ai-phrasing.ts";
+import { unfilledPlaceholderOutsideTemplates } from "../unfilled-placeholder.ts";
 
-export const detector: Detector = unfilledPlaceholder;
+export const detector: Detector = unfilledPlaceholderOutsideTemplates;

package/src/detectors/registry/vague-density.ts

@@ -1,4 +1,4 @@
 import type { Detector } from "../../plugin.ts";
-import { vagueDensity } from "../lexicon.ts";
+import { vagueDensity } from "../vague-density.ts";
 
 export const detector: Detector = vagueDensity;

package/src/detectors/request-owner.ts

@@ -1,6 +1,6 @@
 // A request for an action (「資料をご確認ください」 "Please send the report.") with no deadline and no person or role,
 // in its own sentence or the next. The words come from the language's lexicons; the code only combines them.
-import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, StructureNode } from "../plugin.ts";
+import type { Detector, Finding, Lexicon, ProseDocument, Section, Sentence, Span, StructureNode } from "../plugin.ts";
 import { proseText } from "../measure.ts";
 import { comparableWords } from "./lexicon-match.ts";
 import { escapeRegExp } from "../orthography.ts";
@@ -15,6 +15,9 @@ export const REQUEST_LEXICONS = {
   owner: "request-owner",
   pointer: "request-pointer",
   offer: "request-offer",
+  timing: "request-timing",
+  invitation: "request-invitation",
+  contact: "request-contact",
 } as const;
 
 type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
@@ -32,6 +35,9 @@ const wordsOf = (doc: ProseDocument): Words => ({
   owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
   pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
   offer: patternsOf(doc.lexicons[REQUEST_LEXICONS.offer]),
+  timing: patternsOf(doc.lexicons[REQUEST_LEXICONS.timing]),
+  invitation: patternsOf(doc.lexicons[REQUEST_LEXICONS.invitation]),
+  contact: patternsOf(doc.lexicons[REQUEST_LEXICONS.contact]),
 });
 
 /** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
@@ -57,16 +63,43 @@ export const containsAny = (text: string, patterns: readonly string[]): boolean
 
 const gapBetween = (left: Place, right: Place): number => Math.max(left.start - right.end, right.start - left.end, 0);
 
+/** An invitation verb right at the request ending (「ご相談ください」 "please come"): the reader may come, nothing is to be finished. */
+const INVITATION_REACH = 1;
+
+/** A comma or semicolon between an action and the invitation: the action is a request of its own (「申請書を提出し、会場へお越しください」). */
+const CLAUSE_BREAK = /[、，,;；]/u;
+
+/** A label and a colon (「電話：」 "Fax:"): a contact line, whose request is how to reach the writer. */
+const LABEL_COLON = /^\s*[:：]/u;
+
+/** Whether the action is what the invitation is for (「登録をしにお越しください」「入力用にご使用ください」), not a request beside it. */
+const invitedTo = (comparable: string, action: Place, invitation: Place): boolean => {
+  const [left, right] = action.start <= invitation.start ? [action, invitation] : [invitation, action];
+  return !CLAUSE_BREAK.test(comparable.slice(left.end, right.start));
+};
+
+const holdsContactLine = (text: string, words: Words): boolean => {
+  const comparable = comparableWords(text);
+  return placesOf(comparable, words.contact).some((label) => LABEL_COLON.test(comparable.slice(label.end)));
+};
+
 /**
  * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
  * (「ご不明な点があれば…ください」 is an offer), not an open offer to take the reader's questions (「ご質問はメールでお送りください」),
- * and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * not a pointer to where to read more (「詳細は資料をご確認ください」), not what an invitation is for (「登録をしにお越しください」),
+ * and not the way to reach the writer on a contact line (「ファックス番号：… 送信後、ご連絡ください」).
  * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
  */
 export const isRequest = (text: string, words: Words): boolean => {
+  const comparable = comparableWords(text);
   const endings = placesOf(text, words.ending);
-  const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
-  return asked && ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
+  const invitations = placesOf(text, words.invitation).filter((invitation) => endings.some((ending) => gapBetween(invitation, ending) <= INVITATION_REACH));
+  const asked = placesOf(text, words.action).some(
+    (action) =>
+      endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH) && !invitations.some((invitation) => invitedTo(comparable, action, invitation)),
+  );
+  if (!asked || holdsContactLine(text, words)) return false;
+  return ![words.condition, words.offer, words.pointer].some((patterns) => containsAny(text, patterns));
 };
 
 const NAMED = new Set(["PROPN"]);
@@ -105,13 +138,16 @@ const holdsWord = (sentence: Sentence, patterns: readonly string[]): boolean =>
   return placesOf(comparable, patterns).some((place) => bounds === undefined || (bounds.starts.has(place.start) && bounds.ends.has(place.end)));
 };
 
-/** Whether a sentence says when (a date, a clock time, a deadline word) or who (a role; a name in the request itself). */
+/**
+ * Whether a sentence says when or who (a role). The request itself may also say when relative to something else
+ * (「提出いただく前に」 "before you submit") or name the person; the next sentence's timing or name may be about something else.
+ */
 const saysWhenOrWho = (sentence: Sentence, words: Words, dates: readonly Span[], isRequestItself: boolean): boolean =>
   datedWithin(dates, sentence.span) ||
   CLOCK.test(proseText(sentence)) ||
   holdsWord(sentence, words.deadline) ||
   holdsWord(sentence, words.owner) ||
-  (isRequestItself && namesSomeone(sentence));
+  (isRequestItself && (holdsWord(sentence, words.timing) || namesSomeone(sentence)));
 
 /** A paragraph break or a new list item between two sentences: the second does not continue the first. */
 const BREAK = /\n[^\S\n]*\n|\n[^\S\n]*(?:[-*+]|\d+[.)])[^\S\n]/u;
@@ -122,14 +158,41 @@ const continues = (source: string, sentence: Sentence, next: Sentence | undefine
 const dateSpans = (tree: StructureNode | undefined): Span[] =>
   tree === undefined ? [] : inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : []));
 
-/** The request sentences with neither a deadline nor a person in them or in the sentence after, in the same paragraph or item. */
+/** A section's heading, read as a sentence so the deadline words match it the same way. */
+const headingOf = (section: Section): Sentence => ({
+  span: section.span,
+  text: section.heading,
+  ...(section.headingTokens === undefined ? {} : { tokens: section.headingTokens }),
+});
+
+/** The headings an offset sits under: its own section's, then each enclosing one's up to the title. */
+const enclosingHeadings = (sections: readonly Section[], offset: number): Sentence[] => {
+  const own = sections.findLastIndex((section) => section.span.start <= offset);
+  const chain = sections
+    .slice(0, own + 1)
+    .reduceRight<{ depth: number; found: Section[] }>(
+      (walk, section) => (section.depth < walk.depth ? { depth: section.depth, found: [...walk.found, section] } : walk),
+      { depth: Number.POSITIVE_INFINITY, found: [] },
+    ).found;
+  return chain.filter((section) => section.depth > 0 && section.heading.trim() !== "").map(headingOf);
+};
+
+/**
+ * A notice whose heading names its deadline (「見積提出期限：10月26日」「【随時受付】」): every request under it inherits it.
+ * A date alone in a heading is more often the day the notice was issued or the event it announces, so it is not enough.
+ */
+const underDeadlineHeading = (sections: readonly Section[], sentence: Sentence, words: Words): boolean =>
+  enclosingHeadings(sections, sentence.span.start).some((heading) => holdsWord(heading, words.deadline));
+
+/** The request sentences with neither a deadline nor a person in them, in the sentence after (same paragraph or item), or in a heading above. */
 export const ownerlessRequests = (doc: ProseDocument): Sentence[] => {
   const words = wordsOf(doc);
   const dates = dateSpans(doc.structure);
   return doc.sentences.filter((sentence, index) => {
     if (!isRequest(proseText(sentence), words) || saysWhenOrWho(sentence, words, dates, true)) return false;
     const next = doc.sentences[index + 1];
-    return !continues(doc.source, sentence, next) || !saysWhenOrWho(next, words, dates, false);
+    if (continues(doc.source, sentence, next) && saysWhenOrWho(next, words, dates, false)) return false;
+    return !underDeadlineHeading(doc.sections, sentence, words);
   });
 };
 

package/src/detectors/requirement-smell.ts

@@ -1,16 +1,28 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
+import { classWordsOf, isClassCue, namesClassAfter } from "./open-end-class.ts";
+import { glossesCondition } from "./open-end-condition.ts";
 import { openEndAt, openEndNames, type OpenEndNames } from "./open-end-names.ts";
+import { asksAfter, questionWordsOf } from "./open-end-question.ts";
+import { isScopeCue, openOnPurpose, scopeWordsOf } from "./open-end-scope.ts";
+import { statesConcrete } from "./vague-deadline.ts";
 
 // Requirements smells (Femmer et al. 2017; Berry et al. 2003; ISO/IEC/IEEE 29148): a loophole, an open-ended list and
 // "and/or", in a sentence that states a requirement. What makes a sentence a requirement, and each smell's words, come
 // from the language's lexicons; this file knows neither language.
 
 const OPEN_END = "requirement-open-end";
+const LOOPHOLE = "requirement-loophole";
+/** The words of a question that an open list gives example answers to. */
+const OPEN_QUESTION = "requirement-open-question";
+/** The words of a condition whose bracketed examples an open list may give. */
+const OPEN_CONDITION = "requirement-open-condition";
+const TIME = "time";
+const CONCRETE_DEADLINE = "concrete-deadline";
 
 /** Each smell: the lexicon of its words, and the finding's variant (the rule's messages). */
 const SMELLS = [
-  { lexicon: "requirement-loophole", variant: "loophole" },
+  { lexicon: LOOPHOLE, variant: "loophole" },
   { lexicon: OPEN_END, variant: "open-end" },
   { lexicon: "requirement-either", variant: "either" },
 ] as const;
@@ -43,20 +55,54 @@ const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string, off
   values: { matched: entry.pattern, offset },
 });
 
-/** Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等) is none; without tokens it cannot be told apart. */
+/** A loophole about when (group: time) that the sentence bounds with a stated limit ("as soon as possible, but no later than two days after"). */
+const boundedInTime = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string): boolean =>
+  lexicon === LOOPHOLE &&
+  entry.group === TIME &&
+  statesConcrete(
+    { start: sentence.span.start, text: sentence.text },
+    (doc.lexicons[CONCRETE_DEADLINE] ?? []).map((limit) => limit.pattern),
+  );
+
+/** A lexicon's words; the open-end lexicon also holds the cues of a class named after the list and of what holds it, which are no smell. */
+const smellWords = (doc: ProseDocument, lexicon: string): LexiconEntry[] =>
+  (doc.lexicons[lexicon] ?? []).filter((entry) => !isClassCue(entry) && !isScopeCue(entry));
+
+/**
+ * Where the word stands as a smell. An open-end word inside a name the document gives (業務執行取締役等), giving examples
+ * of a class named right after it (印刷等、二次的に利用), or ending a list a condition, a permission or a prohibition holds
+ * (転載等をしてはならない), is none; without tokens none of these can be told apart.
+ */
 const smellAt = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, names: () => OpenEndNames): number | undefined => {
-  if (!entryIn(sentence, entry)) return undefined;
+  if (!entryIn(sentence, entry) || boundedInTime(doc, sentence, entry, lexicon)) return undefined;
   const tokenized = sentence.tokens !== undefined && (entry.tokens?.length ?? 0) > 0;
-  return lexicon === OPEN_END && tokenized ? openEndAt(doc, sentence, entry, names()) : offsetOf(sentence, entry);
+  if (lexicon !== OPEN_END || !tokenized) return offsetOf(sentence, entry);
+  const classWords = classWordsOf(doc.lexicons[OPEN_END] ?? []);
+  const scopeWords = scopeWordsOf(doc.lexicons[OPEN_END] ?? []);
+  return openEndAt(doc, sentence, entry, names(), (tokens, range) => namesClassAfter(tokens, range, classWords) || openOnPurpose(tokens, range, scopeWords));
 };
 
+/** An open list right before a question the reader answers (…措置など、どのような措置を求めるのか): its items are example answers. */
+const answersQuestion = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, offset: number): boolean =>
+  lexicon === OPEN_END && asksAfter(sentence, offset + entry.pattern.length, questionWordsOf(doc.lexicons[OPEN_QUESTION] ?? []));
+
+/** An open list in brackets right after a condition word (場合（単一テーブルへの SELECT 等）): examples of when, not of what. */
+const glossesConditionAt = (doc: ProseDocument, sentence: Sentence, lexicon: string, offset: number): boolean =>
+  lexicon === OPEN_END &&
+  glossesCondition(
+    sentence,
+    offset,
+    (doc.lexicons[OPEN_CONDITION] ?? []).map((entry) => entry.pattern),
+  );
+
 /** The first word of each smell in one requirement sentence: one finding per smell, not per word. */
 const smellsIn = (doc: ProseDocument, sentence: Sentence, names: () => OpenEndNames): Finding[] =>
   SMELLS.flatMap(({ lexicon, variant }) =>
-    (doc.lexicons[lexicon] ?? [])
+    smellWords(doc, lexicon)
       .flatMap((entry) => {
         const offset = smellAt(doc, sentence, entry, lexicon, names);
-        return offset === undefined ? [] : [findingOf(sentence, entry, variant, offset)];
+        const examples = offset !== undefined && (answersQuestion(doc, sentence, entry, lexicon, offset) || glossesConditionAt(doc, sentence, lexicon, offset));
+        return offset === undefined || examples ? [] : [findingOf(sentence, entry, variant, offset)];
       })
       .slice(0, 1),
   );
@@ -67,6 +113,6 @@ export const requirementSmell: Detector = (doc): Finding[] => {
   const statements = (doc.lexicons[STATEMENTS] ?? []).map((entry) => entry.pattern);
   // Read once, and only when a requirement has an open-end word to tell apart from a name.
   const cache: { names?: OpenEndNames } = {};
-  const names = (): OpenEndNames => (cache.names ??= openEndNames(doc, doc.lexicons[OPEN_END] ?? [], statements));
+  const names = (): OpenEndNames => (cache.names ??= openEndNames(doc, smellWords(doc, OPEN_END), statements));
   return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(doc, sentence, names));
 };

package/src/detectors/scaled-figure-unit.ts

@@ -0,0 +1,103 @@
+// number-without-unit, in prose: a number written with a word of scale and no unit (83,494百万, 83 million) where the
+// document writes that word of scale with one unit many times and without one nowhere else (83,494百万円, $83 million).
+// Pure; the words of scale, the currency marks and the joiners come from the language's lexicons.
+import { escapeRegExp } from "../orthography.ts";
+import type { CurrencyForm } from "./currency-notation.ts";
+import { AMOUNT } from "./currency-notation.ts";
+
+/** A number with a word of scale: from its currency mark (if any) to the end of its unit, and the unit ("" when bare). */
+export type ScaledFigure = { readonly offset: number; readonly end: number; readonly written: string; readonly scale: string; readonly unit: string };
+
+export type ScaleWords = { readonly scales: readonly string[]; readonly forms: readonly CurrencyForm[]; readonly joiners: readonly string[] };
+
+export type ScaleGap = { readonly figure: ScaledFigure; readonly unit: string };
+
+/** How many numbers must carry the unit before the one without it reads as a slip rather than a way of writing. */
+export const MIN_WITH_UNIT = 5;
+
+const LATIN = /[A-Za-z]/u;
+const longestFirst = (words: readonly string[]): string[] => words.toSorted((left, right) => right.length - left.length);
+
+const figurePattern = (scales: readonly string[]): RegExp => {
+  const scale = longestFirst(scales)
+    .map((word) => `${escapeRegExp(word)}${LATIN.test(word) ? "(?![A-Za-z])" : ""}`)
+    .join("|");
+  return new RegExp(`(?<![\\w.,，．０-９])${AMOUNT}\\s?(?:${scale})`, "gu");
+};
+
+const formMatches = (text: string, pattern: string, side: "before" | "after"): boolean => {
+  if (side === "before") return text.endsWith(pattern) && !(LATIN.test(pattern.charAt(0)) && LATIN.test(text.charAt(text.length - pattern.length - 1)));
+  return text.startsWith(pattern) && !(LATIN.test(pattern.at(-1) ?? "") && LATIN.test(text.charAt(pattern.length)));
+};
+
+/** The currency mark written before a number ($, US$, ¥), with the one space it may have. */
+const markBefore = (text: string, offset: number, forms: readonly CurrencyForm[]): string => {
+  const before = text.slice(Math.max(0, offset - 8), offset);
+  const spaced = before.endsWith(" ") ? before.slice(0, -1) : before;
+  const form = longestFirst(forms.filter((entry) => entry.position === "before").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "before"),
+  );
+  if (form === undefined) return "";
+  return spaced === before ? form : `${form} `;
+};
+
+/** What follows a word of scale as its unit: a currency word (円, dollars), else the next word ("people", 人, ドル); "" when none. */
+const unitAfter = (rest: string, forms: readonly CurrencyForm[]): string => {
+  const spaced = rest.startsWith(" ") ? rest.slice(1) : rest;
+  const form = longestFirst(forms.filter((entry) => entry.position === "after").map((entry) => entry.pattern)).find((pattern) =>
+    formMatches(spaced, pattern, "after"),
+  );
+  const word = form ?? /^(?:[A-Za-z]+|[\p{Script=Katakana}ー]+|\p{Script=Han})/u.exec(spaced)?.[0];
+  if (word === undefined) return "";
+  return spaced === rest ? word : ` ${word}`;
+};
+
+const figureAt = (text: string, match: RegExpExecArray, words: ScaleWords): ScaledFigure | undefined => {
+  const end = match.index + match[0].length;
+  const rest = text.slice(end);
+  if (/^\s?[0-9０-９]/u.test(rest)) return undefined;
+  const mark = markBefore(text, match.index, words.forms);
+  const after = mark === "" ? unitAfter(rest, words.forms) : "";
+  const scale = longestFirst(words.scales).find((word) => match[0].endsWith(word)) ?? "";
+  return { offset: match.index - mark.length, end: end + after.length, written: match[0], scale, unit: (mark || after).trim() };
+};
+
+/** Every number with a word of scale in a text, in order; one that runs on into another number (1億2,000万円) is left out. */
+export const scaledFiguresIn = (text: string, words: ScaleWords): ScaledFigure[] =>
+  words.scales.length === 0 ? [] : [...text.matchAll(figurePattern(words.scales))].flatMap((match) => figureAt(text, match, words) ?? []);
+
+/** A bare number joined to its neighbour by a range or list word, so that one unit serves both (100百万〜200百万円). */
+const sharesUnit = (text: string, left: ScaledFigure | undefined, right: ScaledFigure | undefined, joiners: readonly string[]): boolean => {
+  if (left === undefined || right === undefined) return false;
+  const gap = text.slice(left.end, right.offset).trim();
+  return gap === "" || joiners.includes(gap) || joiners.includes(gap.toLowerCase());
+};
+
+const gapOfScale = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const bare = figures.filter(
+    (figure, index) => figure.unit === "" && !sharesUnit(text, figure, figures[index + 1], joiners) && !sharesUnit(text, figures[index - 1], figure, joiners),
+  );
+  const withUnit = figures.filter((figure) => figure.unit !== "");
+  const units = new Set(withUnit.map((figure) => figure.unit));
+  const [unit] = units;
+  const [figure] = bare;
+  if (figure === undefined || unit === undefined || bare.length !== 1 || units.size !== 1 || withUnit.length < MIN_WITH_UNIT) return [];
+  return [{ figure, unit }];
+};
+
+/**
+ * The one bare number of a word of scale whose other numbers all carry one unit, at least MIN_WITH_UNIT times. Two bare
+ * numbers, or two units (百万円 and 百万株), and the document is read as writing the word that way on purpose.
+ */
+export const scaleGaps = (text: string, figures: readonly ScaledFigure[], joiners: readonly string[]): ScaleGap[] => {
+  const scales = [...new Set(figures.map((figure) => figure.scale))];
+  return scales
+    .flatMap((scale) =>
+      gapOfScale(
+        text,
+        figures.filter((figure) => figure.scale === scale),
+        joiners,
+      ),
+    )
+    .toSorted((left, right) => left.figure.offset - right.figure.offset);
+};