chaffjs 0.35.0 → 0.36.0

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/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";

package/src/detectors/opening-date.ts

@@ -0,0 +1,47 @@
+// The date in a document's opening lines: a line that is only a date, or a labelled one, under the title ("January 17,
+// 2024" below a centred heading in plain-text minutes, where the indented title block is no paragraph). Pure.
+import type { Span } from "../plugin.ts";
+import { dateStampIndexes, stampCandidates } from "../date-stamp.ts";
+
+/** How many non-blank lines after the front matter make the title block. */
+const OPENING_LINES = 5;
+/** How many lines from the top are read at most, blank ones and front matter included. */
+const LINE_REACH = 64;
+const FRONT_MATTER_FENCE = "---";
+
+export type DatedSpan = Span & { readonly value: string };
+
+type Line = Span & { readonly text: string };
+
+const firstLines = (source: string): Line[] =>
+  source.split("\n", LINE_REACH).reduce<Line[]>((lines, text) => {
+    const start = (lines.at(-1)?.end ?? -1) + 1;
+    lines.push({ start, end: start + text.length, text });
+    return lines;
+  }, []);
+
+/** The lines after a Markdown front matter block ("---" … "---" at the very top), or all of them. */
+const afterFrontMatter = (lines: readonly Line[]): readonly Line[] => {
+  if (lines[0]?.text.trim() !== FRONT_MATTER_FENCE) return lines;
+  const close = lines.findIndex((line, index) => index > 0 && line.text.trim() === FRONT_MATTER_FENCE);
+  return close === -1 ? lines : lines.slice(close + 1);
+};
+
+const openingLines = (source: string): Line[] =>
+  afterFrontMatter(firstLines(source))
+    .filter((line) => line.text.trim() !== "")
+    .slice(0, OPENING_LINES);
+
+const firstDateIn = (dates: readonly DatedSpan[], line: Span | undefined): string | undefined =>
+  line === undefined ? undefined : dates.find((date) => date.start >= line.start && date.end <= line.end)?.value;
+
+/**
+ * The first date of the first opening line that is a date stamp, as the tree reads it ("2024-01-17"). A label on a line of
+ * its own ("Date:") takes the date on the line after it.
+ */
+export const openingDateOf = (source: string, dates: readonly DatedSpan[], labels: readonly string[]): string | undefined => {
+  const lines = openingLines(source);
+  const stamps = dateStampIndexes(stampCandidates(source, lines, dates), labels);
+  const at = lines.findIndex((_, index) => stamps.has(index));
+  return at === -1 ? undefined : (firstDateIn(dates, lines[at]) ?? firstDateIn(dates, lines[at + 1]));
+};

package/src/detectors/ordinary-phrase.ts

@@ -0,0 +1,62 @@
+// Where a lower-case word that a defined term shares is the ordinary word in a phrase of its own, not the term, and where
+// a quoted term is named rather than used. Pure: the tokens, the source and the lexicons' words are passed in.
+import type { Token } from "../plugin.ts";
+
+/** Words that narrow a noun into a kind of its own (a common parent, a limited liability company). */
+const NARROWING = new Set(["ADJ", "NOUN"]);
+const LOWER_START = /^\p{Ll}/u;
+/** How far back from an opening quote the words that name it as a term are looked for. */
+const CUE_LOOK_BACK = 40;
+const LETTER = /\p{L}/u;
+const LATIN = /\p{Script=Latin}/u;
+
+/**
+ * An adjective or a noun of the same Latin-script phrase right before the use narrows it into a phrase of its own (the
+ * common parent, a limited liability company), unless it is a word that points at the defined thing (the other party).
+ */
+export const isNarrowedUse = (tokens: readonly Token[], at: number, pointers: readonly string[]): boolean => {
+  const before = tokens[at - 1];
+  if (before === undefined || !NARROWING.has(before.pos) || !LATIN.test(before.surface)) return false;
+  return !pointers.some((pointer) => pointer.toLowerCase() === before.surface.toLowerCase());
+};
+
+/**
+ * The use heads a phrase that names a kind of thing with "of" and a bare noun (certificates of deposit, letters of credit);
+ * "of" followed by an article, a pronoun or a name (the certificate of the Company) is the defined thing again.
+ * last is the index of the use's last token.
+ */
+export const headsKindPhrase = (tokens: readonly Token[], last: number): boolean => {
+  const of = tokens[last + 1];
+  const noun = tokens[last + 2];
+  return of !== undefined && noun !== undefined && of.surface.toLowerCase() === "of" && noun.pos === "NOUN" && LOWER_START.test(noun.surface);
+};
+
+/** Every position of part inside whole, overlapping ones too. */
+const positionsOf = (whole: string, part: string): number[] =>
+  Array.from({ length: whole.length }, (_, index) => index).filter((index) => part !== "" && whole.startsWith(part, index));
+
+/** The use sits inside another defined term written out in any case (certificate of merger, where Certificate of Merger is defined). */
+export const insideLongerTerm = (source: string, offset: number, term: string, defined: readonly string[]): boolean =>
+  defined.some((longer) => {
+    if (longer.length <= term.length) return false;
+    const lowerLonger = longer.toLowerCase();
+    return positionsOf(lowerLonger, term.toLowerCase()).some((at) => {
+      const start = offset - at;
+      return start >= 0 && source.slice(start, start + longer.length).toLowerCase() === lowerLonger;
+    });
+  });
+
+/**
+ * A quoted term that the words before its opening quote name as a term (the definition of "Material Adverse Effect",
+ * the term "Affiliate"): the term is mentioned, not used again. opening is the offset of the opening quote.
+ */
+export const isNamedAsTerm = (source: string, opening: number, cues: readonly string[]): boolean => {
+  const before = source
+    .slice(Math.max(0, opening - CUE_LOOK_BACK), opening)
+    .trimEnd()
+    .toLowerCase();
+  return cues.some((cue) => {
+    const lower = cue.toLowerCase();
+    return lower !== "" && before.endsWith(lower) && !LETTER.test(before.charAt(before.length - lower.length - 1));
+  });
+};

package/src/detectors/organisation-run.ts

@@ -1,7 +1,10 @@
 import type { Token } from "../plugin.ts";
 
-/** 組織の名前の前に立つ形（語彙表 organisation-form）と、組織や単位の名前を閉じる語（organisation-unit）。 */
-export type OrganisationWords = { readonly forms: readonly string[]; readonly units: readonly string[] };
+/**
+ * 組織の名前の前に立つ形（語彙表 organisation-form）、そのうち名前の後ろにも立つ法人格（closingForms。株式会社、監査法人）と、
+ * 組織や単位の名前を閉じる語（organisation-unit）。
+ */
+export type OrganisationWords = { readonly forms: readonly string[]; readonly closingForms: readonly string[]; readonly units: readonly string[] };
 
 /** 区切りの前に要る字数。1 字なら、普通の語の一部（外部・本部・課題）と見分けられない。 */
 const MIN_BODY_LENGTH = 2;
@@ -70,6 +73,13 @@ const segmentCount = (run: readonly Token[], units: readonly string[]): number =
   return counts[0] ?? 0;
 };
 
+/**
+ * 法人格で閉じ、その前に 2 字以上の名前がある（東日本自動車販売株式会社、青葉監査法人）。数を含む連なり（2024年株式会社、第三東京販売株式会社）は名前と読まない。
+ * 呼び出し側は、名前に固有名詞か地名があることも求める。法令の語（株式交換完全親株式会社）は法人格で閉じても名前ではない。
+ */
+const endsInForm = (text: string, closingForms: readonly string[]): boolean =>
+  !/[0-9０-９]/u.test(text) && closingForms.some((form) => text.endsWith(form) && [...text].length - [...form].length >= MIN_BODY_LENGTH);
+
 /**
  * 漢字の連なりの語（covering: tokens の添字）が 1 つの組織の名前か。名前は書き手が変えられない。
  * 法人格か地名・固有名詞で始まって組織の語で閉じるもの（国立研究開発法人産業技術総合研究所、紀美野町青少年育成町民会議）、
@@ -79,6 +89,7 @@ const segmentCount = (run: readonly Token[], units: readonly string[]): number =
 export const isOrganisationRun = (tokens: readonly Token[], covering: readonly number[], words: OrganisationWords): boolean => {
   const run = contiguous(tokens, withClosingUnit(tokens, covering, words.units));
   if (run === undefined || run.length === 0) return false;
+  if (endsInForm(surfaceOf(run), words.closingForms) && run.some(isProperPiece) && !run.some(isNumber)) return true;
   const form = formLength(run, new Set(words.forms));
   const head = form > 0 ? form : properLength(run);
   const segments = segmentCount(run.slice(head), words.units);