chaffjs 0.28.0 → 0.30.0

package/src/detectors/capitalised-term.ts

@@ -0,0 +1,147 @@
+// A term written like the document's defined terms, capitalised inside a sentence (its Affiliates, disclose Proprietary
+// Data), that the document defines nowhere. Read only where the document defines its terms with a defining word
+// (MIN_DEFINED of them: "X" means, (the "X")). A capitalised run is also the name of a law, a body, a place, a party or a
+// part of the document, so every name the language package lists is left, and so is every run set apart by markup (a
+// heading, a link, bold, an HTML element, a table row, a list item's label). Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { Span, Token } from "../plugin.ts";
+
+export type CapitalisedTerm = { readonly offset: number; readonly term: string };
+
+/** The word lists the decision reads, matched as written. */
+export type CapitalisedWords = {
+  /** A run holding one of these is a name (Act, Policy, Inc, California, Monday, Supplier), not a term. */
+  readonly names: readonly string[];
+  /** A run opening with one of these points at a part of the document (Section 4, Schedule A). */
+  readonly divisions: readonly string[];
+  /** Small words inside one name (Statement of Work, Trials and Betas). */
+  readonly joiners: readonly string[];
+};
+
+/** A term the document defines; bare is a definition with no defining word (("GPC")), which names more than it defines. */
+export type Defined = { readonly term: string; readonly bare?: boolean };
+
+export type CapitalisedInput = {
+  readonly source: string;
+  /** The text a reader sees (the source without link destinations): where a lower-case use counts. */
+  readonly readable: string;
+  readonly sentences: readonly (readonly Token[])[];
+  readonly defined: readonly Defined[];
+  /** Words set in quotes or bold anywhere ("Account" represents …, **Security Measures**): named on purpose. */
+  readonly named: readonly string[];
+  /** Spans set apart by markup: headings, links, bold, HTML elements, table rows, list items' labels. */
+  readonly marked: readonly Span[];
+  readonly words: CapitalisedWords;
+};
+
+/** Fewer definitions than this, and capitals are the document's style, not its way of naming terms. */
+const MIN_DEFINED = 2;
+const CAPITALISED = /^\p{Lu}\p{Ll}+(?:['’]\p{Ll}+)?$/u;
+const ACRONYM = /^\p{Lu}{2,}$/u;
+const DEFINED_FORM = /^\p{Lu}/u;
+const LOWER_WORD = /^\p{Ll}+$/u;
+const HYPHEN = "-";
+
+const isCapitalised = (token: Token | undefined): boolean => token !== undefined && CAPITALISED.test(token.surface);
+/** A word that carries a run on once it has started: a capitalised word or an acronym (Commercial AI System). */
+const continues = (token: Token | undefined): boolean => isCapitalised(token) || (token !== undefined && ACRONYM.test(token.surface));
+const adjacent = (left: Token, right: Token): boolean => right.span.start - left.span.end <= 1;
+const touching = (left: Token, right: Token): boolean => right.span.start === left.span.end;
+
+/** The forms one term is written in: lower case, its last word as written and singular (Policies, Policy; Viruses, Virus). */
+const formsOf = (term: string): string[] => {
+  const words = term.toLowerCase().split(/[\s-]+/u);
+  const head = words.slice(0, -1).join(" ");
+  const last = words.at(-1) ?? "";
+  const lasts = [last, last.replace(/ies$/u, "y"), last.replace(/es$/u, ""), last.replace(/(?<!s)s$/u, "")];
+  return lasts.map((form) => (head === "" ? form : `${head} ${form}`));
+};
+
+/** How many tokens the capitalised run starting at index takes: words that continue it, and a joiner or hyphen between two. */
+const runLength = (tokens: readonly Token[], index: number, joiners: ReadonlySet<string>): number => {
+  const word = tokens[index];
+  const next = tokens[index + 1];
+  const after = tokens[index + 2];
+  if (next === undefined || word === undefined || !adjacent(word, next)) return 1;
+  if (continues(next)) return 1 + runLength(tokens, index + 1, joiners);
+  const hyphened = next.surface === HYPHEN && touching(word, next) && after !== undefined && touching(next, after);
+  const joined = hyphened || (joiners.has(next.surface) && after !== undefined && adjacent(next, after));
+  return joined && continues(after) ? 2 + runLength(tokens, index + 2, joiners) : 1;
+};
+
+type Run = { readonly start: number; readonly end: number };
+
+/** The capitalised runs of one sentence, as [start, end) token indexes; a run never starts inside the one before. */
+const runsOf = (tokens: readonly Token[], joiners: ReadonlySet<string>): Run[] =>
+  tokens.reduce<Run[]>((runs, token, index) => {
+    if ((runs.at(-1)?.end ?? 0) > index || !isCapitalised(token)) return runs;
+    return [...runs, { start: index, end: index + runLength(tokens, index, joiners) }];
+  }, []);
+
+const inside = (offset: number, spans: readonly Span[]): boolean => spans.some((span) => span.start <= offset && offset < span.end);
+
+/** Used like a defined term: after a lower-case word, and not a modifier of a lower-case noun after it (the Premium plan). */
+const placedLikeATerm = (before: Token | undefined, after: Token | undefined): boolean =>
+  before !== undefined && LOWER_WORD.test(before.surface) && !(after !== undefined && after.pos === "NOUN" && LOWER_WORD.test(after.surface));
+
+/** Every run of whole words in a term (GitHub Service: GitHub, Service, GitHub Service). */
+const partsOf = (term: string): string[] => {
+  const words = term.split(/\s+/u);
+  return words.flatMap((_, start) => words.slice(start).map((__, length) => words.slice(start, start + length + 1).join(" ")));
+};
+
+/** The text also writes the term in lower case (your account, account settings): an ordinary word, or a screen's label. */
+const writtenInLowerCase = (text: string, term: string): boolean => {
+  const words = term
+    .toLowerCase()
+    .split(/[\s-]+/u)
+    .map(escapeRegExp)
+    .join(String.raw`[\s-]+`);
+  return new RegExp(String.raw`(?<!\p{L})${words}(?:e?s)?(?!\p{L})`, "u").test(text);
+};
+
+/**
+ * The first use of each capitalised run used inside a sentence like a defined term that names nothing the language
+ * package lists, is not set apart by markup, is never written in lower case, and neither is nor holds a defined or named
+ * term in any case.
+ */
+export const capitalisedTerms = (input: CapitalisedInput): CapitalisedTerm[] => {
+  const defining = input.defined.filter((definition) => definition.bare !== true && DEFINED_FORM.test(definition.term));
+  if (defining.length < MIN_DEFINED) return [];
+  const joiners = new Set(input.words.joiners);
+  const divisions = new Set(input.words.divisions.flatMap(formsOf));
+  const known = new Set([...input.defined.map((definition) => definition.term), ...input.named, ...input.words.names].flatMap(formsOf));
+  const isKnown = (term: string): boolean => partsOf(term).some((part) => formsOf(part).some((form) => known.has(form)));
+  const uses = input.sentences.flatMap((tokens) =>
+    runsOf(tokens, joiners).flatMap(({ start, end }): CapitalisedTerm[] => {
+      const first = tokens[start];
+      const last = tokens[end - 1];
+      if (first === undefined || last === undefined || !placedLikeATerm(tokens[start - 1], tokens[end])) return [];
+      if (inside(first.span.start, input.marked) || formsOf(first.surface).some((form) => divisions.has(form))) return [];
+      const term = input.source.slice(first.span.start, last.span.end);
+      return isKnown(term) || writtenInLowerCase(input.readable, term) ? [] : [{ offset: first.span.start, term }];
+    }),
+  );
+  return uses.filter((use, index) => uses.findIndex((other) => formsOf(other.term).some((form) => formsOf(use.term).includes(form))) === index);
+};
+
+const BOLD = /\*\*([^*\n]+)\*\*|__([^_\n]+)__/gu;
+const QUOTED = /["“]([^"“”\n]{1,80}?)[,.]?["”]/gu;
+const HTML_ELEMENT = /<([a-z][a-z0-9]*)\b[^>]*>[^<]*<\/\1>/giu;
+const TABLE_ROW = /^[ \t]*\|.*$/gmu;
+const ITEM_LABEL = /^[ \t]*(?:[*+-]|\d+[.)])[ \t]+[^:\n]{1,80}:/gmu;
+
+const spansOf = (source: string, pattern: RegExp): Span[] =>
+  [...source.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+
+/** Bold, HTML elements, table rows and list items' labels in a Markdown source: labels and cells, not running text. */
+export const setApartSpans = (source: string): Span[] => [BOLD, HTML_ELEMENT, TABLE_ROW, ITEM_LABEL].flatMap((pattern) => spansOf(source, pattern));
+
+const LINK_DESTINATION = /\]\([^)\n]*\)|<?https?:\/\/[^\s)>]+>?/gu;
+
+/** The source with link destinations and URLs blanked: the words a reader sees. */
+export const readableText = (source: string): string => source.replaceAll(LINK_DESTINATION, (destination) => " ".repeat(destination.length));
+
+/** The words set in quotes or bold anywhere in a source, without the emphasis marks. */
+export const namedWords = (source: string): string[] =>
+  [BOLD, QUOTED].flatMap((pattern) => [...source.matchAll(pattern)].map((match) => (match[1] ?? match[2] ?? "").replaceAll(/[*_]/gu, "").trim()));

package/src/detectors/citation-entry.ts

@@ -45,17 +45,32 @@ export const namesEntry = (entryKey: string, citedKey: string): boolean => {
   return !LATIN.test(citedKey) && [...surname].length >= MIN_PREFIX_SURNAME && entryKey.startsWith(citedKey);
 };
 
+/**
+ * namesEntry, and also a one-character Japanese surname (森, 林) against the full name it heads (森達也) when no other entry
+ * of that year starts with it: the list then leaves no other work it could name, where 林 beside 林田太郎 and 林正 does.
+ */
+export const namesEntryAmong =
+  (entryKeys: readonly string[]) =>
+  (entryKey: string, citedKey: string): boolean => {
+    if (namesEntry(entryKey, citedKey)) return true;
+    if (LATIN.test(citedKey) || !entryKey.startsWith(citedKey)) return false;
+    return entryKeys.filter((key) => key.startsWith(citedKey)).length === 1;
+  };
+
 const numberedSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
   entries: entries.flatMap((entry) => (entry.number === undefined ? [] : [{ key: String(entry.number), start: entry.start }])),
   citations: marks.filter((mark) => NUMBERED_STYLES.has(mark.style)).map((mark) => ({ mark, keys: mark.numbers.map(String) })),
   names: (entryKey, citedKey) => entryKey === citedKey,
 });
 
-const authorYearSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => ({
-  entries: entries.flatMap((entry) => (entry.authorYear === undefined ? [] : [{ key: keyOf(entry.authorYear), start: entry.start }])),
-  citations: marks.filter((mark) => mark.style === "author-year").map((mark) => ({ mark, keys: mark.authorYears.map(keyOf) })),
-  names: namesEntry,
-});
+const authorYearSide = (entries: readonly ReferenceEntry[], marks: readonly CitationMark[]): Side => {
+  const keyed = entries.flatMap((entry) => (entry.authorYear === undefined ? [] : [{ key: keyOf(entry.authorYear), start: entry.start }]));
+  return {
+    entries: keyed,
+    citations: marks.filter((mark) => mark.style === "author-year").map((mark) => ({ mark, keys: mark.authorYears.map(keyOf) })),
+    names: namesEntryAmong(keyed.map((entry) => entry.key)),
+  };
+};
 
 export const sideSlips = (side: Side): CitationSlip[] => {
   if (side.entries.length < MIN_ENTRIES || side.citations.length === 0) return [];

package/src/detectors/code-before.ts

@@ -0,0 +1,14 @@
+// Whether inline code stands right before a place in the text. Code is masked to blanks before the text is read, so a word
+// after `explain` looks like the head of a sentence, and より after `relaxed` looks like the adverb. Pure.
+
+/**
+ * Whether the last mark before offset on the same line, past spaces, closes inline code (`relaxed` より). prose is the
+ * source with code masked; a backtick it keeps (\` escaped, or one left unclosed) is text, not code.
+ */
+export const followsInlineCode = (source: string, prose: string | undefined, offset: number): boolean => {
+  if (prose === undefined) return false;
+  const lineStart = source.lastIndexOf("\n", offset - 1) + 1;
+  const before = source.slice(lineStart, Math.max(lineStart, offset)).trimEnd();
+  const mark = lineStart + before.length - 1;
+  return before.endsWith("`") && prose.charAt(mark) !== "`";
+};

package/src/detectors/connective-hierarchy.ts

@@ -11,8 +11,15 @@ export type LoneConnective = { readonly offset: number; readonly written: string
 
 const CONJUNCTION = "CCONJ";
 
-/** The word lists the detector reads: the connectives, and the phrases that hold one's letters without being one (歯並びに). */
-export type ConnectiveLists = { readonly connectives: readonly LexiconEntry[]; readonly lookalikes: readonly LexiconEntry[] };
+/**
+ * The word lists the detector reads: the connectives, the phrases that hold one's letters without being one (歯並びに), and
+ * the ends of a condition clause (ときは、): an inner-level word is looked for in the outer-level word's own clause only.
+ */
+export type ConnectiveLists = {
+  readonly connectives: readonly LexiconEntry[];
+  readonly lookalikes: readonly LexiconEntry[];
+  readonly clauseEnds: readonly LexiconEntry[];
+};
 
 /**
  * The tagger does not always tell a connective from a noun and a particle: it reads 申請書並びに as 並び + に and
@@ -62,30 +69,51 @@ const standsAsConnective = (reading: Reading, span: Span): boolean => {
   return tagged || joinsNouns(previous, reading.byStart.get(span.end));
 };
 
-const hasInnerLevel = (sentence: Sentence, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
-  connectives.some((entry) => entry.instead_of === outer.pattern && sentence.text.includes(entry.pattern));
+/**
+ * The clause of the text the letter at `at` is in: from the end of the last clause end before it (ときは、) to the end of
+ * the first one after it. A list in a condition clause and one in the main clause are not levels of one list. A clause
+ * end with a connective right after it (…ときは、又は…場合には) joins two conditions, and does not cut.
+ */
+export const clauseAround = (text: string, at: number, clauseEnds: readonly LexiconEntry[], connectives: readonly LexiconEntry[] = []): string => {
+  const joinsNext = (end: number): boolean => connectives.some(({ pattern }) => pattern !== "" && text.startsWith(pattern, end));
+  const ends = clauseEnds
+    .filter(({ pattern }) => pattern !== "")
+    .flatMap(({ pattern }) => placesOf(text, pattern).map((start) => start + pattern.length))
+    .filter((end) => !joinsNext(end));
+  const start = Math.max(0, ...ends.filter((end) => end <= at));
+  const end = Math.min(text.length, ...ends.filter((end) => end > at));
+  return text.slice(start, end);
+};
+
+const hasInnerLevel = (clause: string, outer: LexiconEntry, connectives: readonly LexiconEntry[]): boolean =>
+  connectives.some((entry) => entry.instead_of === outer.pattern && clause.includes(entry.pattern));
 
-/** Where one outer-level word stands as a connective in the sentence. */
-const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading): Span[] =>
+/** Where one outer-level word stands as a connective in the sentence with no inner-level word in its clause. */
+const connectiveSpans = (sentence: Sentence, outer: LexiconEntry, reading: Reading, lists: ConnectiveLists): Span[] =>
   placesOf(sentence.text, outer.pattern)
     .filter((at) => reading.hidden[at] !== true)
+    .filter((at) => !hasInnerLevel(clauseAround(sentence.text, at, lists.clauseEnds, lists.connectives), outer, lists.connectives))
     .map((at) => ({ start: sentence.span.start + at, end: sentence.span.start + at + outer.pattern.length }))
     .filter((span) => standsAsConnective(reading, span));
 
 /** The outer-level connectives of a sentence that stand over no inner level. */
 export const loneConnectivesIn = (sentence: Sentence, lists: ConnectiveLists): LoneConnective[] => {
-  const lone = lists.connectives.filter(
-    (entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern) && !hasInnerLevel(sentence, entry, lists.connectives),
-  );
+  const lone = lists.connectives.filter((entry) => entry.rewrite !== undefined && sentence.text.includes(entry.pattern));
   if (lone.length === 0) return [];
   const reading = readingOf(sentence, lists.lookalikes);
   return lone
-    .flatMap((entry) => connectiveSpans(sentence, entry, reading).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })))
+    .flatMap((entry) =>
+      connectiveSpans(sentence, entry, reading, lists).map((span) => ({ offset: span.start, written: entry.pattern, usual: entry.rewrite ?? "" })),
+    )
     .sort((a, b) => a.offset - b.offset);
 };
 
 export const connectiveHierarchy: Detector = (doc, options): Finding[] => {
-  const lists = { connectives: options.lexicon ?? [], lookalikes: doc.lexicons["connective-lookalike"] ?? [] };
+  const lists = {
+    connectives: options.lexicon ?? [],
+    lookalikes: doc.lexicons["connective-lookalike"] ?? [],
+    clauseEnds: doc.lexicons["connective-clause-end"] ?? [],
+  };
   return doc.sentences.flatMap((sentence) =>
     loneConnectivesIn(sentence, lists).map((lone) => ({
       rule: "",

package/src/detectors/currency-notation.ts

@@ -1,6 +1,7 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
 import { escapeRegExp } from "../orthography.ts";
 import { formMinority } from "./form-minority.ts";
+import { proseAndTablesOf } from "../table-text.ts";
 import { quoteAround } from "./quote-around.ts";
 
 // 一つの文書で、同じ通貨の金額を二通りに書いた所（1,000円 と ¥1,000、$20 と 20 dollars）。どちらが正しいかは決めず、少ないほうを指す。
@@ -77,7 +78,7 @@ export const formsOf = (doc: ProseDocument): CurrencyForm[] =>
   );
 
 export const currencyNotation: Detector = (doc, options): Finding[] => {
-  const text = doc.prose ?? doc.source;
+  const text = proseAndTablesOf(doc);
   const multipliers = (doc.lexicons["amount-multiplier"] ?? []).map((entry) => entry.pattern);
   return currencyMinorities(amountsIn(text, formsOf(doc), multipliers), options.limit).map(({ odd, usual, count, of }) => ({
     rule: "",

package/src/detectors/date-outside-period.ts

@@ -0,0 +1,41 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { datesOutsidePeriod, type OutsideWords } from "../structure/date-outside-period.ts";
+import { rangeFrameOf } from "../structure/date-range.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+/** 期間の語、期間の外に置く語、文書の仕事の期間の語、締め切りの語、概要の節の見出しの語、範囲の記号（range-connector、range-opener、range-frame の間の語）、月と曜日の名は語彙表から取る。 */
+const wordsOf = (doc: ProseDocument): OutsideWords => ({
+  labels: patternsOf(doc, "period-label"),
+  terms: patternsOf(doc, "period-term-label"),
+  asides: patternsOf(doc, "period-aside"),
+  deadlines: patternsOf(doc, "period-deadline"),
+  overviews: patternsOf(doc, "period-overview-heading"),
+  connectors: [
+    ...patternsOf(doc, "range-connector"),
+    ...patternsOf(doc, "range-opener"),
+    ...patternsOf(doc, "range-frame").flatMap((pattern) => rangeFrameOf(pattern)?.joint ?? []),
+  ],
+  months: patternsOf(doc, "month-name"),
+  weekdays: patternsOf(doc, "weekday"),
+});
+
+/** 書いた期間（旅行期間：…）の外の日付を持つ、その後ろの日程の項目、表の行、見出し。 */
+export const dateOutsidePeriod: Detector = (doc): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const dates = inDocumentOrder(doc.structure).flatMap((node) =>
+    node.kind === "date" ? [{ offset: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : [],
+  );
+  const headings = doc.markup?.headings ?? [];
+  const sentences = doc.sentences.map((sentence) => sentence.span);
+  return datesOutsidePeriod(doc.source, dates, headings, sentences, wordsOf(doc)).map((issue) => ({
+    rule: "date-outside-period",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));
+};

package/src/detectors/default-values.ts

@@ -0,0 +1,17 @@
+// default-value-mismatch: one parameter's default stated two ways on a page (default-values.ts). The header words of a
+// default column and the phrases that state a default in prose come from the default-header and default-phrase lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { defaultSlips } from "../default-values.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const lowercase = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+export const defaultValues: Detector = (doc): Finding[] =>
+  defaultSlips(doc.source, { headers: lowercase(doc, "default-header"), phrases: lowercase(doc, "default-phrase") }).map((slip) => ({
+    rule: "default-value-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, slip.offset),
+    values: { name: slip.name, value: slip.value, expected: slip.expected, offset: slip.offset },
+  }));

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

@@ -5,6 +5,8 @@ import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../struct
 import { escapeRegExp } from "../orthography.ts";
 import { prefixGroupsOf, prefixVariants, variantUses } from "../structure/term-prefix.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { isPartOfAddress } from "./address-word.ts";
+import { exactOffsets, extendedAfter, extendedBefore } from "./term-extension.ts";
 import type { Detector, Finding, ProseDocument, Sentence, Span, Token } from "../plugin.ts";
 
 const bodyOf = (doc: ProseDocument): BodyText[] => doc.sentences.map((sentence) => ({ start: sentence.span.start, text: sentence.text }));
@@ -50,17 +52,32 @@ export const quotedUses = (source: string, term: string, uses: readonly number[]
   });
 
 const UPPER_START = /^\p{Lu}/u;
+/** The capital that starts each later word of a term (the O of Records Officer). */
+const INNER_CAPITAL = /(?<=\s)\p{Lu}/gu;
+
+const innerCapitals = (term: string): number[] => [...term.matchAll(INNER_CAPITAL)].map((match) => match.index);
+
+/** Whether the letter at position at of the term is written in lower case at this use. */
+const isLowered = (source: string, term: string, offset: number, at: number): boolean => source.charAt(offset + at) === term.charAt(at).toLowerCase();
+
+/** The term with the capitals of its later words in lower case (Records officer), whose uses the term's own form does not find. */
+export const innerLowered = (term: string): string => term.replace(INNER_CAPITAL, (capital) => capital.toLowerCase());
 
 /**
- * The uses of a capitalised term written in lower case ("services" where "Services" is defined), when they are the fewer
- * and at most limit: a document that mostly writes it in lower case uses the word in its ordinary sense on purpose.
+ * The uses of a capitalised term written in lower case ("services" where "Services" is defined, "records officer" where
+ * "Records Officer" is), when they are no more than the capitalised uses and at most limit: a document that writes it in
+ * lower case more often uses the word in its ordinary sense on purpose. One of each is a slip to point at (the Software,
+ * then the software).
  */
 export const lowerCaseUses = (source: string, term: string, uses: readonly number[], definedAt: number, limit: number): number[] => {
   if (!UPPER_START.test(term) || term.toLowerCase() === term) return [];
-  const later = uses.filter((offset) => offset > definedAt);
-  const lower = later.filter((offset) => source.charAt(offset) === term.charAt(0).toLowerCase() && !isSentenceStart(source, offset));
-  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0));
-  return lower.length > 0 && lower.length < capital.length && lower.length <= limit ? lower : [];
+  const inner = innerCapitals(term);
+  // An address (support@pinecone.example) spells the name as the address must be, in either case; it is not a use.
+  const later = uses.filter((offset) => offset > definedAt && !isPartOfAddress(source, offset, offset + term.length));
+  const innerLower = (offset: number): boolean => inner.some((at) => isLowered(source, term, offset, at));
+  const lower = later.filter((offset) => (isLowered(source, term, offset, 0) && !isSentenceStart(source, offset)) || innerLower(offset));
+  const capital = later.filter((offset) => source.charAt(offset) === term.charAt(0) && !innerLower(offset));
+  return lower.length > 0 && lower.length <= capital.length && lower.length <= limit ? lower : [];
 };
 
 /** How far back a sentence's start is looked for: past a few spaces to the mark before them. */
@@ -74,16 +91,22 @@ const isSentenceStart = (source: string, offset: number): boolean => {
   return (offset < LOOK_BACK && text === "") || before.slice(text.length).includes("\n") || SENTENCE_END.has(text.at(-1) ?? "");
 };
 
+const definingSentence = (doc: ProseDocument, definition: Span): Sentence | undefined =>
+  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end);
+
 /** Where the sentence holding the definition ends: a use inside it ("Customer" means the party named "Customer") belongs to the definition. */
-const definingSentenceEnd = (doc: ProseDocument, definition: Span): number =>
-  doc.sentences.find((sentence) => sentence.span.start <= definition.start && definition.start < sentence.span.end)?.span.end ?? definition.end;
+const definingSentenceEnd = (doc: ProseDocument, definition: Span): number => definingSentence(doc, definition)?.span.end ?? definition.end;
 
 const VERBAL = new Set(["VERB", "AUX"]);
 
+const tokensAt = (doc: ProseDocument, offset: number): { readonly tokens: readonly Token[]; readonly at: number } => {
+  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
+  return { tokens, at: tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end) };
+};
+
 /** A word used as a verb ("you input"), not the defined thing ("the Input"): a different word that shares the spelling. */
 const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
-  const tokens = doc.sentences.find((candidate) => candidate.span.start <= offset && offset < candidate.span.end)?.tokens ?? [];
-  const at = tokens.findIndex((candidate) => candidate.span.start <= offset && offset < candidate.span.end);
+  const { tokens, at } = tokensAt(doc, offset);
   const token = tokens[at];
   if (token === undefined) return false;
   // After a subject pronoun the word is its verb (you input), whatever the tagger says; after a possessive (your input) it is a noun.
@@ -92,6 +115,26 @@ const isVerbAt = (doc: ProseDocument, offset: number): boolean => {
   return VERBAL.has(token.pos) || afterSubject;
 };
 
+const NAMING = new Set(["NOUN", "PROPN"]);
+
+/**
+ * A lower-case phrase that starts with a noun and has no adjective before it (the records officer) names the defined thing.
+ * One that starts with an adjective or a possessive (its own confidential information, your content), or that an
+ * adjective narrows (additional terms of service), is the ordinary phrase.
+ */
+const isNamingAt = (doc: ProseDocument, offset: number): boolean => {
+  const { tokens, at } = tokensAt(doc, offset);
+  return NAMING.has(tokens[at]?.pos ?? "") && tokens[at - 1]?.pos !== "ADJ";
+};
+
+/** The uses of the term, with those that write its later words in lower case (records officer for Records Officer), in order. */
+const withLoweredWords = (doc: ProseDocument, term: string, texts: readonly BodyText[], spans: readonly Span[], uses: readonly number[]): number[] => {
+  const lowered = innerLowered(term);
+  if (lowered === term) return [...uses];
+  const more = usesOf(lowered, texts, spans, "loose").filter((offset) => !uses.includes(offset) && isNamingAt(doc, offset));
+  return [...uses, ...more].toSorted((left, right) => left - right);
+};
+
 /** The term written with another prefix of its group (本件業務 where 本業務 is defined), after the sentence that defines it. */
 const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, definingEnd: number, defined: readonly string[]): Finding[] =>
   prefixVariants(term.term, prefixGroupsOf(doc.lexicons["defined-term-prefix"] ?? [])).flatMap((variant) =>
@@ -102,6 +145,33 @@ const prefixFindings = (doc: ProseDocument, texts: readonly BodyText[], term: De
         ),
   );
 
+/** The term set in quotes again, unless the document's profile says a quoted term is the term mentioned (「株主」とあるのは). */
+const quotedFindings = (doc: ProseDocument, term: DefinedTerm, uses: readonly number[], definingEnd: number): Finding[] =>
+  doc.profile?.quoteMentionsTerm === true
+    ? []
+    : quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
+        finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
+      );
+
+/** The term written longer with a word of its definition (文書管理責任者, the Application), after the sentence that defines it. */
+const extendedFindings = (doc: ProseDocument, texts: readonly BodyText[], term: DefinedTerm, spans: readonly Span[], defined: readonly string[]): Finding[] => {
+  const definition = definingSentence(doc, term.span)?.text ?? "";
+  const pointers = (doc.lexicons["defined-term-pointer"] ?? []).map((entry) => entry.pattern);
+  // Every sentence that defines the term (a second definition too) holds the long words it is defined from.
+  const defining = spans.map((span) => definingSentence(doc, span)?.span ?? span);
+  const definingEnd = definingSentenceEnd(doc, term.span);
+  return texts
+    .flatMap((text) => exactOffsets(text.text, text.start, term.term))
+    .filter((offset) => offset > definingEnd && !defining.some((span) => span.start <= offset && offset < span.end))
+    .flatMap((offset) => {
+      const before = extendedBefore(doc.source, offset, term.term, definition, pointers);
+      const written = before ?? (isSentenceStart(doc.source, offset) ? undefined : extendedAfter(doc.source, offset, term.term, definition));
+      if (written === undefined || defined.includes(written)) return [];
+      const start = before === undefined ? offset : offset + term.term.length - written.length;
+      return [finding(doc, "defined-term-form", start, "extended", { term: term.term, written, line: term.line })];
+    });
+};
+
 export const definedTermForm: Detector = (doc, options): Finding[] => {
   if (doc.structure === undefined) return [];
   const texts = bodyOf(doc);
@@ -110,14 +180,13 @@ export const definedTermForm: Detector = (doc, options): Finding[] => {
   return firstDefinitions(terms).flatMap(({ term, spans }) => {
     const uses = usesOf(term.term, texts, spans, "loose");
     const definingEnd = definingSentenceEnd(doc, term.span);
-    const quoted = quotedUses(doc.source, term.term, uses, definingEnd).map((offset) =>
-      finding(doc, "defined-term-form", offset, "quoted", { term: term.term, line: term.line }),
-    );
-    const nounUses = uses.filter((offset) => !isVerbAt(doc, offset));
+    const quoted = quotedFindings(doc, term, uses, definingEnd);
+    const caseUses = withLoweredWords(doc, term.term, texts, spans, uses);
+    const nounUses = caseUses.filter((offset) => !isVerbAt(doc, offset));
     const lower = lowerCaseUses(doc.source, term.term, nounUses, definingEnd, options.limit).map((offset) =>
       finding(doc, "defined-term-form", offset, "case", { term: term.term, line: term.line }),
     );
-    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined)];
+    return [...quoted, ...lower, ...prefixFindings(doc, texts, term, definingEnd, defined), ...extendedFindings(doc, texts, term, spans, defined)];
   });
 };
 

package/src/detectors/definition-use.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type Mentioned } from "../structure/definition-use.ts";
+import { definedTerms, unusedDefinitions, usesBeforeDefinition, type BodyText, type IsTitle, type Mentioned } from "../structure/definition-use.ts";
+import { titleLineNumbers } from "../structure/title-lines.ts";
 import { expansionConflicts, expansionsIn } from "../acronym-expansions.ts";
 import { linesOf, lineNumberAt } from "../structure/lines.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
@@ -29,11 +30,18 @@ export const unusedDefinition: Detector = (doc): Finding[] =>
         findingAt(doc, defined.span.start, { term: defined.term }),
       );
 
+/** 題・見出し（Markdown の見出し、章・節の行、条の前の見出しの行）の上の位置か。 */
+const titleIn = (doc: ProseDocument): IsTitle => {
+  const lines = linesOf(doc.source);
+  const numbers = titleLineNumbers(doc.structure, lines, doc.markup?.headings ?? []);
+  return (offset) => numbers.has(lineNumberAt(lines, offset) ?? 0);
+};
+
 /** 文の途中で括弧に入れて定義した語を、定義より前で使っている所。 */
 export const useBeforeDefinition: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc)).map((use) =>
+    : usesBeforeDefinition(definedTerms(doc.structure), bodyOf(doc), mentionedIn(doc), titleIn(doc)).map((use) =>
         findingAt(doc, use.offset, { term: use.term.term, defined: use.term.line }),
       );
 

package/src/detectors/deprecated-use.ts

@@ -0,0 +1,17 @@
+// deprecated-option-used: a name the document calls deprecated, still used in one of its code examples
+// (deprecated-use.ts). The words come from the deprecation-word and deprecation-negated lexicons.
+import { quoteAt } from "./structure-tree.ts";
+import { deprecatedUses } from "../deprecated-use.ts";
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+
+const lowercase = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern.toLowerCase());
+
+export const deprecatedUse: Detector = (doc): Finding[] =>
+  deprecatedUses(doc.source, { words: lowercase(doc, "deprecation-word"), negated: lowercase(doc, "deprecation-negated") }).map((use) => ({
+    rule: "deprecated-option-used",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, use.offset),
+    values: { name: use.name, offset: use.offset },
+  }));