chaffjs 0.28.0 → 0.29.0

package/src/detectors/registry/kana-function-word.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { kanaFunctionWord } from "../kana-function-word.ts";
+
+export const detector: Detector = kanaFunctionWord;

package/src/detectors/registry/line-amount.ts

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

package/src/detectors/registry/nado-closed-list.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { nadoClosedList } from "../nado-closed-list.ts";
+
+export const detector: Detector = nadoClosedList;

package/src/detectors/registry/number-word-figure.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { numberWordFigure } from "../number-word-figure.ts";
+
+export const detector: Detector = numberWordFigure;

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

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { obligationWithoutDeadline } from "../obligation-without-deadline.ts";
+
+export const detector: Detector = obligationWithoutDeadline;

package/src/detectors/registry/parameter-table.ts

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

package/src/detectors/registry/phone-number-variant.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { phoneNumberVariant } from "../phone-number-variant.ts";
+
+export const detector: Detector = phoneNumberVariant;

package/src/detectors/registry/prerequisite-order.ts

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

package/src/detectors/registry/quote-unnamed-speaker.ts

@@ -0,0 +1,4 @@
+import type { Detector } from "../../plugin.ts";
+import { quoteUnnamedSpeaker } from "../quote-unnamed-speaker.ts";
+
+export const detector: Detector = quoteUnnamedSpeaker;

package/src/detectors/registry/tax-amount.ts

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

package/src/detectors/registry/time-order.ts

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

package/src/detectors/registry/ui-label.ts

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

package/src/detectors/registry/undefined-call.ts

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

package/src/detectors/registry/undefined-term.ts

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

package/src/detectors/registry/version-order.ts

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

package/src/detectors/registry/warning-action.ts

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

package/src/detectors/requirement-smell.ts

@@ -1,20 +1,25 @@
 import type { Detector, Finding, Lexicon, LexiconEntry, ProseDocument, Sentence } from "../plugin.ts";
 import { entryCloses, entryIn, entryRanges } from "./lexicon-match.ts";
+import { openEndAt, openEndNames, type OpenEndNames } from "./open-end-names.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";
+
 /** Each smell: the lexicon of its words, and the finding's variant (the rule's messages). */
 const SMELLS = [
   { lexicon: "requirement-loophole", variant: "loophole" },
-  { lexicon: "requirement-open-end", variant: "open-end" },
+  { lexicon: OPEN_END, variant: "open-end" },
   { lexicon: "requirement-either", variant: "either" },
 ] as const;
 
 const MARKERS = "requirement-marker";
 /** Sentence ends that look like a marker and are not one (「…のこと。」 defines a term). The language may have none. */
 const NOT_MARKERS = "requirement-not-marker";
+/** The language's words of a definition (をいう, means): a name defined with them closes its own list (銀行等（…をいう。）). */
+const STATEMENTS = "definition-statement";
 
 /** A marker with position: after counts only at the end of the sentence (「…できること。」); any other, anywhere in it. */
 const isMarkedBy = (sentence: Sentence, entry: LexiconEntry): boolean => (entry.position === "after" ? entryCloses(sentence, entry) : entryIn(sentence, entry));
@@ -28,25 +33,40 @@ const offsetOf = (sentence: Sentence, entry: LexiconEntry): number => {
   return range === undefined ? sentence.span.start : (sentence.tokens?.[range.start]?.span.start ?? sentence.span.start);
 };
 
-const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string): Finding => ({
+const findingOf = (sentence: Sentence, entry: LexiconEntry, variant: string, offset: number): Finding => ({
   rule: "",
   severity: "warning",
   line: 0,
   column: 0,
   quote: sentence.text.trim(),
   variant,
-  values: { matched: entry.pattern, offset: offsetOf(sentence, entry) },
+  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. */
+const smellAt = (doc: ProseDocument, sentence: Sentence, entry: LexiconEntry, lexicon: string, names: () => OpenEndNames): number | undefined => {
+  if (!entryIn(sentence, entry)) 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);
+};
+
 /** The first word of each smell in one requirement sentence: one finding per smell, not per word. */
-const smellsIn = (sentence: Sentence, lexicons: ProseDocument["lexicons"]): Finding[] =>
-  SMELLS.flatMap(({ lexicon, variant }) => {
-    const entry = (lexicons[lexicon] ?? []).find((candidate) => entryIn(sentence, candidate));
-    return entry === undefined ? [] : [findingOf(sentence, entry, variant)];
-  });
+const smellsIn = (doc: ProseDocument, sentence: Sentence, names: () => OpenEndNames): Finding[] =>
+  SMELLS.flatMap(({ lexicon, variant }) =>
+    (doc.lexicons[lexicon] ?? [])
+      .flatMap((entry) => {
+        const offset = smellAt(doc, sentence, entry, lexicon, names);
+        return offset === undefined ? [] : [findingOf(sentence, entry, variant, offset)];
+      })
+      .slice(0, 1),
+  );
 
 export const requirementSmell: Detector = (doc): Finding[] => {
   const markers = doc.lexicons[MARKERS] ?? [];
   const notMarkers = doc.lexicons[NOT_MARKERS] ?? [];
-  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(sentence, doc.lexicons));
+  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));
+  return doc.sentences.filter((sentence) => isRequirement(sentence, markers, notMarkers)).flatMap((sentence) => smellsIn(doc, sentence, names));
 };

package/src/detectors/structure-tree.ts

@@ -7,10 +7,12 @@ import { documentDateOf } from "./document-date.ts";
 import { dateOrderBreaks } from "../structure/date-order.ts";
 import { totalMismatches, type Amount } from "../structure/total.ts";
 import { proseTotalMismatches } from "../structure/prose-total.ts";
+import { countedAmounts, type SummedCounter } from "../structure/counted-amounts.ts";
 import { rangeFrameOf, reversedRanges, type DatedSpan, type RangeWords } from "../structure/date-range.ts";
 import { percentSumMismatches, type ShareWords } from "../structure/percent-sum.ts";
 import { proseShareMismatches } from "../structure/percent-sum-prose.ts";
 import { isQuotedAlone } from "../quoted-span.ts";
+import { ordinalRunGaps } from "./ordinal-run-gaps.ts";
 
 const QUOTE_LENGTH = 80;
 
@@ -48,28 +50,34 @@ const QUOTED_LINE = /^[ \t]*>/u;
 /** 引用の中の箇条書きは、ほかの文書の例で、この文書の番号ではない。 */
 const isQuotedList = (source: string, start: number): boolean => QUOTED_LINE.test(source.slice(lineStartAt(source, start), start));
 
-const listNumberingGaps = (doc: ProseDocument): Finding[] =>
-  doc.lists
-    .filter((list) => !isQuotedList(doc.source, list.span.start))
-    .flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []))
-    .map((issue) => ({
-      rule: "numbering-gap",
-      severity: "error",
-      line: 0,
-      column: 0,
-      quote: quoteAt(doc.source, issue.offset),
-      values: { ...issue.values, offset: issue.offset },
-    }));
+const listNumberingGaps = (doc: ProseDocument): StructureIssue[] =>
+  doc.lists.filter((list) => !isQuotedList(doc.source, list.span.start)).flatMap((list) => listNumberBreaks(writtenNumbers(doc.source, list.itemSpans) ?? []));
+
+const lineFindingOf = (doc: ProseDocument, issue: StructureIssue): Finding => ({
+  rule: "numbering-gap",
+  severity: "error",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, issue.offset),
+  values: { ...issue.values, offset: issue.offset },
+});
 
 /**
- * 番号の抜けと重なり: 番地の木の並び（条、項、号）と、Markdown の番号付きの箇条書きに書いた番号。条の中の「1.」「2.」は
- * 両方に読まれるので、木が指した行の箇条書きは重ねて言わない。
+ * 番号の抜けと重なり: 番地の木の並び（条、項、号）、Markdown の番号付きの箇条書きに書いた番号、日程の第N回・Week N の並び
+ * （detectors/ordinal-run-gaps.ts）。一つの行が二つ以上に読まれる（条の中の「1.」、「1. Week 1」）ので、先に指した行は重ねて言わない。
  */
 export const numberingGap: Detector = (doc, options): Finding[] => {
   const fromTree = structureNumberingGap(doc, options);
   const reported = new Set(fromTree.map((finding) => lineStartAt(doc.source, Number(finding.values["offset"]))));
-  const fromLists = listNumberingGaps(doc).filter((finding) => !reported.has(lineStartAt(doc.source, Number(finding.values["offset"]))));
-  return [...fromTree, ...fromLists].toSorted((left, right) => Number(left.values["offset"]) - Number(right.values["offset"]));
+  const fromLines = [...listNumberingGaps(doc), ...ordinalRunGaps(doc)].filter((issue) => {
+    const line = lineStartAt(doc.source, issue.offset);
+    if (reported.has(line)) return false;
+    reported.add(line);
+    return true;
+  });
+  return [...fromTree, ...fromLines.map((issue) => lineFindingOf(doc, issue))].toSorted(
+    (left, right) => Number(left.values["offset"]) - Number(right.values["offset"]),
+  );
 };
 export const duplicateDefinition: Detector = findingsOf("duplicate-definition", duplicateDefinitions);
 
@@ -141,33 +149,43 @@ export const dateWeekdayMismatch: Detector = (doc): Finding[] => {
 };
 
 /** 木の日付を、原文の位置と一緒に並べる。 */
-const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
+export const datedPoints = (tree: NonNullable<ProseDocument["structure"]>): { offset: number; value: string }[] =>
   inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [{ offset: node.span.start, value: String(node.attrs["value"]) }] : []));
 
-/** 日程の並びに逆らう日付。並びの読み方は原文の行を見るので、木と原文の両方を渡す。 */
+/** 日程の並びに逆らう日付。並びの読み方は原文の行と見出しを見るので、木と原文と見出しを渡す。 */
 export const dateOrder: Detector = (doc): Finding[] =>
   doc.structure === undefined
     ? []
-    : dateOrderBreaks(doc.source, datedPoints(doc.structure)).map((issue) => ({
+    : dateOrderBreaks(doc.source, datedPoints(doc.structure), doc.markup?.headings ?? []).map((issue) => ({
         rule: "date-order",
         severity: "warning",
         line: 0,
         column: 0,
         quote: quoteAt(doc.source, issue.offset),
         values: { ...issue.values, offset: issue.offset },
+        ...("next" in issue.values ? { variant: "first" } : {}),
       }));
 
 /** 木の数量を、原文の位置と一緒に並べる。 */
-const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
+export const amountsOf = (tree: NonNullable<ProseDocument["structure"]>): Amount[] =>
   inDocumentOrder(tree).flatMap((node) =>
     node.kind === "quantity" ? [{ offset: node.span.start, end: node.span.end, value: Number(node.attrs["value"]), unit: String(node.attrs["unit"]) }] : [],
   );
 
 const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
 
+const summedCountersOf = (doc: ProseDocument): SummedCounter[] =>
+  (doc.lexicons["summed-counter"] ?? []).map((entry) => ({ pattern: entry.pattern, unit: entry.group ?? entry.pattern }));
+
+/** 木の数量に、解析器が助数詞と読まない足せる助数詞（16単位、3 credits）の付いた数を加えて、書いた順に並べる。 */
+const summableAmountsOf = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): Amount[] => {
+  const known = amountsOf(tree);
+  return [...known, ...countedAmounts(doc.source, summedCountersOf(doc), known)].toSorted((left, right) => left.offset - right.offset);
+};
+
 /** 合計の行と内訳の行、文の中の合計と内訳。同じ金額は一度だけ言う。 */
 const totalIssues = (doc: ProseDocument, tree: NonNullable<ProseDocument["structure"]>): StructureIssue[] => {
-  const amounts = amountsOf(tree);
+  const amounts = summableAmountsOf(doc, tree);
   const lines = totalMismatches(doc.source, amounts, patternsOf(doc, "total-label"));
   const words = {
     totals: patternsOf(doc, "total-phrase"),
@@ -230,7 +248,11 @@ export const dateRangeReversed: Detector = (doc): Finding[] => {
 
 const shareWordsOf = (doc: ProseDocument): ShareWords => ({
   labels: (doc.lexicons["share-label"] ?? []).map((entry) => entry.pattern),
+  columnLabels: (doc.lexicons["share-column"] ?? []).map((entry) => entry.pattern),
+  rates: (doc.lexicons["share-column-rate"] ?? []).map((entry) => entry.pattern),
   exceptions: (doc.lexicons["share-exception"] ?? []).map((entry) => entry.pattern),
+  rests: (doc.lexicons["share-rest"] ?? []).map((entry) => entry.pattern),
+  changes: (doc.lexicons["change-direction"] ?? []).map((entry) => entry.pattern),
   units: (doc.lexicons["percent-unit"] ?? []).map((entry) => entry.pattern),
   totalLabels: (doc.lexicons["total-label"] ?? []).map((entry) => entry.pattern),
 });

package/src/detectors/superlative-scope.ts

@@ -42,6 +42,18 @@ const compound = (tokens: readonly Token[], range: TokenRange): boolean => {
   return before !== undefined && first !== undefined && NOMINAL.has(before.pos) && before.span.end === first.span.start;
 };
 
+const CLAUSE_END = new Set(["VERB", "AUX"]);
+
+/**
+ * 連体修飾の節が空白を挟まずに付いた最上級（バグを検出できる唯一の・社員が選んだ最高の）。節が何の中で最もなのかを言う。
+ * 節の終わりは原形の動詞か助動詞。「首都であり最大の」の「あり」と「大切な最大の」の「な」は原形でないので節の終わりと読まない。
+ */
+const clauseBefore = (tokens: readonly Token[], range: TokenRange): boolean => {
+  const before = tokens[range.start - 1];
+  const first = tokens[range.start];
+  return before !== undefined && first !== undefined && CLAUSE_END.has(before.pos) && before.surface === before.lemma && before.span.end === first.span.start;
+};
+
 /** 名前 + 範囲の語 + 最上級（日本で最も・トヨタで最も・東京都で最大）。「費用で最大の効果」の「費用」は名前ではないので範囲にしない。 */
 const namedBefore = (tokens: readonly Token[], range: TokenRange, markers: Lexicon): boolean =>
   isMarker(tokens[range.start - 1], markers) && isNamed(tokens[range.start - 2]);
@@ -68,4 +80,4 @@ const phraseAfter = (tokens: readonly Token[], range: TokenRange, markers: Lexic
 };
 
 export const scoped = (tokens: readonly Token[], range: TokenRange, markers: ScopeMarkers): boolean =>
-  compound(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);
+  compound(tokens, range) || clauseBefore(tokens, range) || namedBefore(tokens, range, markers.before) || phraseAfter(tokens, range, markers.after);

package/src/detectors/tax-amount.ts

@@ -0,0 +1,25 @@
+// tax-mismatch: the reading half. The words of a tax row, a total row and an included tax come from the language's
+// lexicons (tax-label, total-label, tax-included-word); the amounts are the structure tree's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { taxMismatches, type TaxWords } from "../structure/tax.ts";
+import { amountsOf, quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const wordsOf = (doc: ProseDocument): TaxWords => ({
+  labels: patternsOf(doc, "tax-label"),
+  totals: patternsOf(doc, "total-label"),
+  included: patternsOf(doc, "tax-included-word"),
+});
+
+export const taxAmount: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : taxMismatches(doc.source, amountsOf(doc.structure), wordsOf(doc)).map((issue) => ({
+        rule: "tax-mismatch",
+        severity: "error",
+        line: 0,
+        column: 0,
+        quote: quoteAt(doc.source, issue.offset),
+        values: { ...issue.values, offset: issue.offset },
+      }));

package/src/detectors/technical-docs.ts

@@ -190,6 +190,11 @@ const MIN_STEPS = 3;
 const isInflected = (token: Token): boolean =>
   token.lemma !== undefined && token.lemma !== "" && token.surface.toLowerCase() !== token.lemma && token.features?.["VerbForm"] !== "Part";
 
+const NOMINAL = new Set(["NOUN", "PROPN"]);
+
+/** A determiner right after a noun opens a clause inside the phrase (a buffer that is big): the verb after it is the clause's, not a subject's. */
+const opensClause = (words: readonly Token[]): boolean => words.some((token, at) => at > 0 && token.pos === "DET" && NOMINAL.has(words[at - 1]?.pos ?? ""));
+
 /**
  * A step written as a statement: a subject, then its verb. The subject opens with an article or a pronoun (The installer
  * asks, You click), or it is a name or a noun whose verb is inflected (Docker builds). A noun before a base-form verb is
@@ -201,7 +206,8 @@ export const isStatement = (tokens: readonly Token[]): boolean => {
   if (head === undefined || words.length < MIN_STEP_TOKENS || !SUBJECT_HEAD.has(head.pos)) return false;
   const verbAt = rest.findIndex((token) => PREDICATE.has(token.pos));
   const verb = rest[verbAt];
-  if (verb === undefined || !rest.slice(0, verbAt).every((token) => SUBJECT_PART.has(token.pos))) return false;
+  const subject = [head, ...rest.slice(0, verbAt)];
+  if (verb === undefined || !rest.slice(0, verbAt).every((token) => SUBJECT_PART.has(token.pos)) || opensClause(subject)) return false;
   // Punctuation before the verb is no subject: a label (Guests: the users who …) or an opening phrase (On the left bar, select …).
   const interrupted = tokens.some((token) => token.pos === "PUNCT" && token.span.start > head.span.start && token.span.start < verb.span.start);
   return !interrupted && (SUBJECT_OPENER.has(head.pos) || isInflected(verb));

package/src/detectors/term-extension.ts

@@ -0,0 +1,67 @@
+// A defined term written longer, with a word of its own definition added: 文書管理責任者 where 「管理責任者」とは、…文書の
+// 管理の責任者をいう is defined, the Application where the Pinecone Notes application (the "App") is. The reader cannot tell
+// whether the longer word is the defined thing or another one. Pure.
+import { escapeRegExp } from "../orthography.ts";
+
+/** The letters a Japanese compound is made of: a word written right before the term joins it into one longer word. */
+const COMPOUND_CHAR = /[\p{Script=Han}\p{Script=Katakana}ー]/u;
+const LATIN_LETTER = /\p{Script=Latin}/u;
+const UPPER_START = /^\p{Lu}/u;
+/** An added part shorter than this (書, the s of Services) is an ending or one character, not a word of the definition. */
+const MIN_ADDED = 2;
+/** A term shorter than this (提供, 登録) is an ordinary word that joins other words freely (情報提供, 利用登録). */
+const MIN_COMPOUND_TERM = 3;
+/** A plural ending (Boxes) is the same word, not a longer one. */
+const PLURAL = /^e?s$/u;
+
+/** The whole character that starts at, or ends right before, a position: both halves of 𠮷, not one. */
+const charFrom = (source: string, at: number): string => String.fromCodePoint(source.codePointAt(at) ?? 0);
+const charBefore = (source: string, at: number): string => {
+  const low = source.charCodeAt(at - 1);
+  const isLowHalf = low >= 0xdc00 && low <= 0xdfff && at >= 2;
+  return isLowHalf ? source.slice(at - 2, at) : source.charAt(at - 1);
+};
+
+/** Where the run of compound characters that ends at offset starts. */
+const runStart = (source: string, offset: number): number => {
+  let start = offset;
+  for (let char = charBefore(source, start); start > 0 && COMPOUND_CHAR.test(char); char = charBefore(source, start)) start -= char.length;
+  return start;
+};
+
+/** The endings of a run, longest first, that are long enough to be a word added to the term. */
+const endingsOf = (run: string): string[] => Array.from({ length: Math.max(0, run.length - MIN_ADDED + 1) }, (_, index) => run.slice(index));
+
+/**
+ * The term at offset written with more in front of it in one word (文書管理責任者), when what is in front ends with a word of
+ * the definition (文書). A word that points at one of the defined things (当該管理責任者) does not lengthen it, and a longer
+ * word the definition itself writes (東京都（以下「都」という。）) is the long name, not another form of the term.
+ */
+export const extendedBefore = (source: string, offset: number, term: string, definition: string, pointers: readonly string[] = []): string | undefined => {
+  if ([...term].length < MIN_COMPOUND_TERM || COMPOUND_CHAR.test(charFrom(source, offset + term.length))) return undefined;
+  const run = source.slice(runStart(source, offset), offset);
+  const added = endingsOf(run).find((part) => definition.includes(part) && !pointers.some((pointer) => part.startsWith(pointer)));
+  const written = added === undefined ? undefined : `${added}${term}`;
+  return written === undefined || definition.includes(written) ? undefined : written;
+};
+
+/**
+ * The capitalised term at offset written with more letters after it in one word (App → Application), when the definition
+ * has that longer word (the Pinecone Notes application). A plural or a word joined to letters before it is not one.
+ */
+export const extendedAfter = (source: string, offset: number, term: string, definition: string): string | undefined => {
+  if (!UPPER_START.test(term) || LATIN_LETTER.test(source.charAt(offset - 1))) return undefined;
+  let end = offset + term.length;
+  while (LATIN_LETTER.test(source.charAt(end))) end += 1;
+  const added = source.slice(offset + term.length, end);
+  if (added.length < MIN_ADDED || PLURAL.test(added)) return undefined;
+  const word = source.slice(offset, end);
+  return new RegExp(String.raw`(?<!\p{L})${escapeRegExp(word)}(?!\p{L})`, "iu").test(definition) ? word : undefined;
+};
+
+/** Each place the term is written exactly, in order. */
+export const exactOffsets = (text: string, start: number, term: string): number[] => {
+  const offsets: number[] = [];
+  for (let at = text.indexOf(term); at !== -1 && term !== ""; at = text.indexOf(term, at + term.length)) offsets.push(start + at);
+  return offsets;
+};

package/src/detectors/time-order.ts

@@ -0,0 +1,49 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import type { StructureIssue } from "../structure/issues.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { clockTimes } from "../compare/clock-time.ts";
+import { secondsOf, type DateSpan, type Mark, type TimeSpan, type TimeWords } from "../structure/time-marks.ts";
+import { timeOrderBreaks } from "../structure/time-order.ts";
+import { arrivalsBeforeDeparture } from "../structure/leg-times.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+// 一日の予定の時刻の順番（time-order）と、発より前の着（arrival-before-departure）。時刻は compare/clock-time.ts が読み、
+// 発着・翌日・時間帯の語は言語パッケージの語彙表（leg-mark、leg-column、day-shift-mark、time-zone、local-time-mark）から取る。
+
+const marksOf = (doc: ProseDocument, lexicon: string): Mark[] =>
+  (doc.lexicons[lexicon] ?? []).map((entry) => ({ pattern: entry.pattern, position: entry.position, group: entry.group }));
+
+const timeWordsOf = (doc: ProseDocument): TimeWords => ({
+  legs: marksOf(doc, "leg-mark"),
+  columns: marksOf(doc, "leg-column"),
+  dayShifts: marksOf(doc, "day-shift-mark"),
+  zones: [...marksOf(doc, "time-zone"), ...marksOf(doc, "local-time-mark").map((mark) => ({ ...mark, group: "local" }))],
+});
+
+const datesOf = (doc: ProseDocument): DateSpan[] =>
+  doc.structure === undefined
+    ? []
+    : inDocumentOrder(doc.structure).flatMap((node) =>
+        node.kind === "date" ? [{ start: node.span.start, end: node.span.end, value: String(node.attrs["value"]) }] : [],
+      );
+
+const timesOf = (text: string): TimeSpan[] => clockTimes(text).map((time) => ({ start: time.start, end: time.end, seconds: secondsOf(time.key) }));
+
+type Finder = (source: string, times: readonly TimeSpan[], dates: readonly DateSpan[], words: TimeWords) => StructureIssue[];
+
+/** 表と箇条書きを行のまま読むので、原文を渡す（doc.prose は表を覆う）。 */
+const detectorOf =
+  (rule: string, find: Finder): Detector =>
+  (doc): Finding[] =>
+    find(doc.source, timesOf(doc.source), datesOf(doc), timeWordsOf(doc)).map((issue) => ({
+      rule,
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, issue.offset),
+      values: { ...issue.values, offset: issue.offset },
+      ...("next" in issue.values ? { variant: "first" } : {}),
+    }));
+
+export const timeOrder: Detector = detectorOf("time-order", timeOrderBreaks);
+export const arrivalBeforeDeparture: Detector = detectorOf("arrival-before-departure", arrivalsBeforeDeparture);

package/src/detectors/ui-label.ts

@@ -0,0 +1,17 @@
+// ui-label-variant: one label on the screen written two ways in a manual (ui-labels.ts). The words a label is written with or
+// without come from the language's label-particle lexicon.
+import { quoteAt } from "./structure-tree.ts";
+import { labelsIn, labelVariants } from "../ui-labels.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const uiLabel: Detector = (doc): Finding[] => {
+  const particles = (doc.lexicons["label-particle"] ?? []).map((entry) => entry.pattern);
+  return labelVariants(labelsIn(doc.source, doc.prose ?? doc.source), particles).map(({ label, usual }) => ({
+    rule: "ui-label-variant",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, label.offset),
+    values: { written: label.surface, usual, offset: label.offset },
+  }));
+};

package/src/detectors/unbalanced-bracket.ts

@@ -4,6 +4,7 @@ import { escapeRegExp } from "../orthography.ts";
 import { quoteAround } from "./quote-around.ts";
 import { mergeSpans } from "../span-merge.ts";
 import { firstEndingAfter } from "../soft-break.ts";
+import { isLabelClose, isLabelInAside } from "./bracket-label.ts";
 
 /**
  * 括弧の組。どの言語でも同じ字の決まりなので、語彙表ではなくここに置く。family は形（丸・角）で、全角と半角は同じ形の別の幅。
@@ -48,31 +49,23 @@ export type BracketProblem = {
 type Open = { readonly bracket: Bracket; readonly offset: number };
 type Scan = { readonly open: Open[]; readonly problems: BracketProblem[] };
 
-/**
- * 丸括弧の閉じの前の、行の頭か空白・句読点の後ろに書いた短い印（「1)」「a)」「事例）」「※）」）と、数の後ろの閉じ（「事例2）及び事例3）」）。
- * 箇条の番号や見出しの印で、開きを持たない書き方。顔文字の「:)」も同じ形。印に使うのは丸括弧だけ。
- */
-const LABEL_BEFORE = /(?:^|[\s、。,;:：])[^\s()（）[\]［］「」『』]{1,3}[ \t\u3000]?$|[\d０-９]$/u;
-
-const isLabel = (text: string, bracket: Bracket, offset: number): boolean => {
-  if (bracket.family !== "round") return false;
-  const lineStart = text.lastIndexOf("\n", offset - 1) + 1;
-  return LABEL_BEFORE.test(text.slice(lineStart, offset));
-};
-
 const unclosedOf = (entry: Open): BracketProblem => ({ kind: "unclosed", offset: entry.offset, mark: entry.bracket.open });
 
 const closeWith = (scan: Scan, text: string, bracket: Bracket, offset: number): void => {
   const at = scan.open.findLastIndex((entry) => entry.bracket.family === bracket.family);
+  const round = bracket.family === "round";
   if (at === -1) {
-    if (!isLabel(text, bracket, offset)) scan.problems.push({ kind: "unopened", offset, mark: bracket.close });
+    if (!(round && isLabelClose(text, offset))) scan.problems.push({ kind: "unopened", offset, mark: bracket.close });
     return;
   }
+  if (round && isLabelInAside(text, offset, scan.open.filter((entry) => entry.bracket.family === "round").length)) return;
   const opened = scan.open[at];
-  // 間に残った開きは、この閉じより先に閉じるはずだったもの。
+  // 間に残った開きは、この閉じより先に閉じるはずだったもの。ただし引用の閉じのすぐ前の開きは、括弧の字そのものを
+  // 引いたもの（法令の読替え「取締役（」とあるのは「清算人（」と）で、組を作らない。
   scan.open
     .splice(at)
     .slice(1)
+    .filter((inner) => !(QUOTATIONS.has(bracket.family) && inner.offset === offset - 1))
     .forEach((inner) => scan.problems.push(unclosedOf(inner)));
   if (opened !== undefined && opened.bracket !== bracket) scan.problems.push({ kind: "mismatch", offset, mark: bracket.close, partner: opened.bracket.open });
 };

package/src/detectors/undefined-call.ts

@@ -0,0 +1,19 @@
+// undefined-function-call: a function called in a code example that the page never defines, where the page documents
+// one whose name it extends (wrapText( on a page about wrap) (undefined-call.ts). The functions a programming language
+// provides come from the code-global lexicon.
+import { quoteAt } from "./structure-tree.ts";
+import { undefinedCalls } from "../undefined-call.ts";
+import type { Detector, Finding } from "../plugin.ts";
+
+export const undefinedCall: Detector = (doc): Finding[] => {
+  const headings = (doc.markup?.headings ?? []).map((heading) => heading.text);
+  const globals = (doc.lexicons["code-global"] ?? []).map((entry) => entry.pattern);
+  return undefinedCalls(doc.source, headings, globals).map((call) => ({
+    rule: "undefined-function-call",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, call.offset),
+    values: { name: call.name, documented: call.documented, offset: call.offset },
+  }));
+};