chaffjs 0.20.0 → 0.22.0

package/src/detectors/code-fences.ts

@@ -0,0 +1,113 @@
+// Fenced code blocks (``` or ~~~) and inline code spans of a Markdown source. Pure. A fence's language is the first word
+// of its info string (```bash, ```{r}); a fence inside a blockquote is someone else's and is not read.
+import { parse } from "../markdown-read.ts";
+import { spanOf } from "../markdown-node.ts";
+import { eachPreOrder } from "../tree-walk.ts";
+
+export type CodeFence = {
+  /** Where the opening fence line starts. */
+  readonly start: number;
+  /** The first word of the info string, lower-cased; "" when the fence names none. */
+  readonly language: string;
+  /** The lines between the fences. */
+  readonly lines: readonly string[];
+  /** Where the block ends: the end of the closing fence line, or of the document. */
+  readonly end: number;
+};
+
+export type CodeSpan = { readonly start: number; readonly text: string };
+
+const MIN_FENCE = 3;
+
+type Opening = { readonly mark: string; readonly length: number };
+
+/** The fence a code block's first line opens, with its info string; undefined for an indented block, which has none. */
+export const fenceOf = (line: string): { readonly fence: Opening; readonly info: string } | undefined => {
+  const mark = line.charAt(0);
+  if (mark !== "`" && mark !== "~") return undefined;
+  const length = [...line].findIndex((char) => char !== mark);
+  const run = length === -1 ? line.length : length;
+  if (run < MIN_FENCE) return undefined;
+  const info = line.slice(run).trim();
+  // A backtick fence's info string has no backtick: ```js``` on one line is an inline span.
+  return mark === "`" && info.includes("`") ? undefined : { fence: { mark, length: run }, info };
+};
+
+/** The language an info string names: its first word, without braces or a leading dot ({r}, {.python}). */
+export const languageOf = (info: string): string => {
+  const word = info.split(/\s/u)[0] ?? "";
+  const opened = word.startsWith("{") ? word.slice(1) : word;
+  const bare = opened.startsWith(".") ? opened.slice(1) : opened;
+  const cut = [...bare].findIndex((char) => char === "{" || char === "}" || char === ",");
+  return (cut === -1 ? bare : bare.slice(0, cut)).toLowerCase();
+};
+
+/** How many backticks run from `at`. */
+const runAt = (text: string, at: number): number => {
+  const state = { end: at };
+  while (text.charAt(state.end) === "`") state.end += 1;
+  return state.end - at;
+};
+
+/** The fences of the last source read: the three rules that read fences parse a document once. */
+const lastRead: { source: string | undefined; fences: readonly CodeFence[] } = { source: undefined, fences: [] };
+
+const isQuoted = (source: string, offset: number): boolean =>
+  source
+    .slice(source.lastIndexOf("\n", offset - 1) + 1, offset)
+    .trimStart()
+    .startsWith(">");
+
+/**
+ * Every fenced code block, in order, as the Markdown parser reads it: a fence in a list item is one, an indented code
+ * block (four spaces, no fence) is not, and an unclosed fence runs to the end. A fence inside a quotation is left out.
+ */
+export const codeFences = (source: string): readonly CodeFence[] => {
+  if (lastRead.source === source) return lastRead.fences;
+  const fences: CodeFence[] = [];
+  eachPreOrder(parse(source), (node) => {
+    const span = node.type === "code" ? spanOf(node) : undefined;
+    if (span === undefined || isQuoted(source, span.start)) return;
+    const lineEnd = source.indexOf("\n", span.start);
+    // A fenced block starts at its fence; an indented block starts at its indentation, which is no fence.
+    const opening = fenceOf(source.slice(span.start, lineEnd === -1 ? source.length : lineEnd).trimEnd());
+    if (opening === undefined) return;
+    fences.push({ start: span.start, language: languageOf(opening.info), lines: (node.value ?? "").split("\n"), end: span.end });
+  });
+  lastRead.source = source;
+  lastRead.fences = fences;
+  return fences;
+};
+
+/** Inline code spans in a stretch of text: a run of backticks closed by a run of the same length. */
+export const codeSpans = (text: string, offset = 0): CodeSpan[] => {
+  const spans: CodeSpan[] = [];
+  const state = { at: 0 };
+  while (state.at < text.length) {
+    const open = text.indexOf("`", state.at);
+    if (open === -1) break;
+    const length = runAt(text, open);
+    const fence = "`".repeat(length);
+    const close = findRun(text, fence, open + length);
+    if (close === -1) {
+      state.at = open + length;
+    } else {
+      spans.push({ start: offset + open, text: text.slice(open + length, close).trim() });
+      state.at = close + length;
+    }
+  }
+  return spans;
+};
+
+/** The next run of exactly this many backticks from `from`, or -1. */
+const findRun = (text: string, run: string, from: number): number => {
+  const state = { at: from };
+  while (state.at < text.length) {
+    const found = text.indexOf(run, state.at);
+    if (found === -1) return -1;
+    if (text.charAt(found + run.length) !== "`" && text.charAt(found - 1) !== "`") return found;
+    state.at = found + run.length;
+    while (text.charAt(state.at) === "`") state.at += 1;
+  }
+  return -1;
+};

package/src/detectors/cross-definitions.ts

@@ -0,0 +1,49 @@
+import type { CrossDetector, DocumentFinding, ProseDocument, StructureNode } from "../plugin.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+import { definitionsOutOfStep, type DefinitionOutOfStep, type WrittenDefinition } from "../structure/cross-definitions.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+// cross-doc-duplicate-definition reads definitions as duplicate-definition does (the tree's definition nodes), and compares
+// what each file says after the term: 「X」とは、…をいう / "X" means ….
+
+/**
+ * A definition that stands alone: not one held within an article or section (scope local), and not the inline kind
+ * (以下「X」という, ("X")), whose meaning is written before the term rather than after it.
+ */
+const standsAlone = (node: StructureNode): boolean =>
+  node.kind === "definition" && node.attrs["scope"] !== "local" && node.attrs["placement"] !== "inline" && node.attrs["term"] !== undefined;
+
+/** The language's words of a definition (をいう, means): the definition-statement word list. */
+const statementWordsOf = (doc: ProseDocument): string[] => (doc.lexicons["definition-statement"] ?? []).map((entry) => entry.pattern);
+
+/**
+ * What the sentence says after the term, up to its end. Empty when the sentence has none of the words of a definition:
+ * 「『AI が書いた』とは言いません」 names the term without defining it.
+ */
+const bodyAfter = (doc: ProseDocument, node: StructureNode, statementWords: readonly string[]): string => {
+  const sentence = doc.sentences.find((candidate) => candidate.span.start <= node.span.start && node.span.start < candidate.span.end);
+  if (sentence === undefined || node.span.end > sentence.span.end) return "";
+  const text = doc.source.slice(sentence.span.start, sentence.span.end);
+  return statementWords.some((word) => text.includes(word)) ? doc.source.slice(node.span.end, sentence.span.end) : "";
+};
+
+const definitionsOf = (doc: ProseDocument, tree: StructureNode): WrittenDefinition[] => {
+  const statementWords = statementWordsOf(doc);
+  return inDocumentOrder(tree)
+    .filter(standsAlone)
+    .map((node) => ({ term: String(node.attrs["term"]), body: bodyAfter(doc, node, statementWords), offset: node.span.start }));
+};
+
+const findingOf = (byPath: ReadonlyMap<string, ProseDocument>, odd: DefinitionOutOfStep): DocumentFinding[] => {
+  const doc = byPath.get(odd.path);
+  if (doc === undefined) return [];
+  const values = { term: odd.definition.term, count: odd.files, example: odd.usual.path, offset: odd.definition.offset };
+  return [{ path: odd.path, finding: { rule: "", severity: "warning", line: 0, column: 0, quote: quoteAt(doc.source, odd.definition.offset), values } }];
+};
+
+/** A term defined in other words than in most files of the run that define it: reported in the files of the fewer wording. */
+export const crossDocDuplicateDefinition: CrossDetector = (docs) => {
+  const files = docs.flatMap((doc) => (doc.structure === undefined ? [] : [{ path: doc.path, definitions: definitionsOf(doc, doc.structure) }]));
+  const byPath = new Map(docs.map((doc) => [doc.path, doc]));
+  return definitionsOutOfStep(files).flatMap((odd) => findingOf(byPath, odd));
+};

package/src/detectors/cross-facts.ts

@@ -0,0 +1,60 @@
+import type { CrossDetector, DocumentFinding, ProseDocument, Span, StructureNode } from "../plugin.ts";
+import { nameSpans } from "../compare/proper-nouns.ts";
+import { overlapsAny, spanIndex } from "../compare/spans.ts";
+import { factValues } from "../facts/fact-values.ts";
+import { labelledFacts, type Fact } from "../facts/labelled-facts.ts";
+import { tableFacts } from "../facts/table-facts.ts";
+import { emailSpans, versionSpans } from "../facts/address-values.ts";
+import { scopedFacts, type ScopedFact } from "../facts/fact-scope.ts";
+import { factsOutOfStep, writtenValue, type FactOutOfStep } from "../facts/cross-facts.ts";
+import { factWordsOf } from "./fact-consistency.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+// cross-doc-fact-conflict reads facts as fact-conflict does (fact-consistency.ts), with two more kinds of value that a docs
+// site repeats from page to page: an email address and a version of three parts or more (2.4.1, v3).
+
+/** The proper nouns, and the addresses and versions, read as values named by what they are. A name inside an address is the address. */
+const namedValues = (doc: ProseDocument): Span[] => {
+  const extra = [...emailSpans(doc.source), ...versionSpans(doc.source)];
+  const taken = spanIndex(extra);
+  return [...nameSpans(doc).filter((span) => !overlapsAny(taken, span)), ...extra];
+};
+
+const summaryHeadings = (doc: ProseDocument): string[] => (doc.lexicons["summary-heading"] ?? []).map((entry) => entry.pattern);
+
+/** A colon right before the value, past emphasis marks: "Fee: $12", 「料金：1,200円」, "**Fee:** $12". */
+const COLON_BEFORE = /[:：][\s*_]*$/u;
+
+/**
+ * A fact written as an entry: "Item: value", or a table cell. A fact in a sentence (「指摘は 3 件です」) is about what that
+ * page is saying, and the same words on another page are often about something else; within one file, fact-conflict reads them.
+ */
+const isEntry = (source: string, fact: Fact): boolean => COLON_BEFORE.test(source.slice(source.lastIndexOf("\n", fact.value.start - 1) + 1, fact.value.start));
+
+const factsOf = (doc: ProseDocument, tree: StructureNode): ScopedFact[] => {
+  const values = factValues(tree, doc.source, namedValues(doc));
+  const entries = labelledFacts(doc.source, values, factWordsOf(doc)).filter((fact) => isEntry(doc.source, fact));
+  return scopedFacts([...entries, ...tableFacts(doc.source, values)], tree, doc.source, summaryHeadings(doc));
+};
+
+const findingOf = (byPath: ReadonlyMap<string, ProseDocument>, odd: FactOutOfStep): DocumentFinding[] => {
+  const doc = byPath.get(odd.path);
+  const usualDoc = byPath.get(odd.usual.path);
+  if (doc === undefined || usualDoc === undefined) return [];
+  const values = {
+    label: odd.fact.label,
+    value: writtenValue(doc.source, odd.fact.value),
+    other: writtenValue(usualDoc.source, odd.usual.value.value),
+    count: odd.files,
+    example: odd.usual.path,
+    offset: odd.fact.value.start,
+  };
+  return [{ path: odd.path, finding: { rule: "", severity: "warning", line: 0, column: 0, quote: quoteAt(doc.source, odd.fact.value.start), values } }];
+};
+
+/** A labelled fact given one value in some files of the run and another in the rest: reported in the files of the fewer value. */
+export const crossDocFactConflict: CrossDetector = (docs) => {
+  const files = docs.flatMap((doc) => (doc.structure === undefined ? [] : [{ path: doc.path, facts: factsOf(doc, doc.structure) }]));
+  const byPath = new Map(docs.map((doc) => [doc.path, doc]));
+  return factsOutOfStep(files).flatMap((odd) => findingOf(byPath, odd));
+};

package/src/detectors/cross-registry/cross-doc-duplicate-definition.ts

@@ -0,0 +1,4 @@
+import type { CrossDetector } from "../../plugin.ts";
+import { crossDocDuplicateDefinition } from "../cross-definitions.ts";
+
+export const detector: CrossDetector = crossDocDuplicateDefinition;

package/src/detectors/cross-registry/cross-doc-fact-conflict.ts

@@ -0,0 +1,4 @@
+import type { CrossDetector } from "../../plugin.ts";
+import { crossDocFactConflict } from "../cross-facts.ts";
+
+export const detector: CrossDetector = crossDocFactConflict;

package/src/detectors/currency-notation.ts

@@ -0,0 +1,90 @@
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { formMinority } from "./form-minority.ts";
+import { quoteAround } from "./quote-around.ts";
+
+// 一つの文書で、同じ通貨の金額を二通りに書いた所（1,000円 と ¥1,000、$20 と 20 dollars）。どちらが正しいかは決めず、少ないほうを指す。
+// 通貨の書き方、それを金額のどちら側に書くか、どの通貨か（group）は語彙表 currency-notation、桁の語は amount-multiplier が言う。
+
+export type CurrencyForm = { readonly pattern: string; readonly position: "before" | "after"; readonly currency: string };
+
+/** 金額 1 つ。form は書き方（側と記号）、currency はその通貨。 */
+export type WrittenAmount = { readonly offset: number; readonly written: string; readonly form: string; readonly currency: string };
+
+/** 少ないほうの書き方の金額と、多いほうの書き方の例、その通貨の金額の数。 */
+export type CurrencyMinority = { readonly odd: WrittenAmount; readonly usual: string; readonly count: number; readonly of: number };
+
+const AMOUNT = "[0-9０-９]+(?:[,，][0-9０-９]{3})*(?:[.．][0-9０-９]+)?";
+
+const alternation = (words: readonly string[]): string => words.map(escapeRegExp).join("|");
+
+/** 記号が英字で始まる・終わるなら、語の中（USDT、dollarsign）を読まないよう英字の切れ目を求める。 */
+const latinEdge = (pattern: string, side: "start" | "end"): string => {
+  const edge = side === "start" ? pattern.charAt(0) : pattern.charAt(pattern.length - 1);
+  if (!/[A-Za-z]/u.test(edge)) return "";
+  return side === "start" ? "(?<![A-Za-z])" : "(?![A-Za-z])";
+};
+
+const amountPattern = (form: CurrencyForm, multipliers: readonly string[]): RegExp => {
+  const mark = escapeRegExp(form.pattern);
+  const multiplier = multipliers.length === 0 ? "" : `(?:\\s?(?:${alternation(multipliers)}))?`;
+  return form.position === "before"
+    ? new RegExp(`${latinEdge(form.pattern, "start")}${mark}\\s?${AMOUNT}${multiplier}(?![A-Za-z0-9０-９])`, "gu")
+    : new RegExp(`(?<![\\w.,，０-９])${AMOUNT}${multiplier}\\s?${mark}${latinEdge(form.pattern, "end")}`, "gu");
+};
+
+const overlaps = (left: WrittenAmount, right: WrittenAmount): boolean =>
+  left.offset < right.offset + right.written.length && right.offset < left.offset + left.written.length;
+
+/** 文字列の中の金額と、その書き方。重なる所に二つの書き方が当たれば、記号の長いほう（US$ と $ なら US$、米ドル と ドル なら 米ドル）。 */
+export const amountsIn = (text: string, forms: readonly CurrencyForm[], multipliers: readonly string[]): WrittenAmount[] =>
+  forms
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((form) =>
+      [...text.matchAll(amountPattern(form, multipliers))].map((match) => ({
+        offset: match.index,
+        written: match[0],
+        form: `${form.position}:${form.pattern}`,
+        currency: form.currency,
+      })),
+    )
+    .reduce<WrittenAmount[]>((kept, amount) => (kept.some((other) => overlaps(other, amount)) ? kept : [...kept, amount]), [])
+    .toSorted((left, right) => left.offset - right.offset);
+
+const minorityOf = (ofCurrency: readonly WrittenAmount[], limit: number): CurrencyMinority[] => {
+  const minority = formMinority(ofCurrency, limit);
+  if (minority === undefined) return [];
+  return minority.odd.map((amount) => ({ odd: amount, usual: minority.usual.written, count: minority.odd.length, of: ofCurrency.length }));
+};
+
+/**
+ * 通貨ごとに、多いほうと違う書き方の金額。少ないほうが limit パーセントを超えれば、使い分けている文書と読んで言わない。
+ * いちばん多い書き方が同じ数で並べば、どちらにも立たない。
+ */
+export const currencyMinorities = (amounts: readonly WrittenAmount[], limit: number): CurrencyMinority[] =>
+  [...new Set(amounts.map((amount) => amount.currency))]
+    .flatMap((currency) =>
+      minorityOf(
+        amounts.filter((amount) => amount.currency === currency),
+        limit,
+      ),
+    )
+    .toSorted((left, right) => left.odd.offset - right.odd.offset);
+
+const formsOf = (doc: ProseDocument): CurrencyForm[] =>
+  (doc.lexicons["currency-notation"] ?? []).flatMap((entry) =>
+    entry.position === undefined || entry.group === undefined ? [] : [{ pattern: entry.pattern, position: entry.position, currency: entry.group }],
+  );
+
+export const currencyNotation: Detector = (doc, options): Finding[] => {
+  const text = doc.prose ?? doc.source;
+  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: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, odd.offset, odd.offset + odd.written.length),
+    values: { written: odd.written.trim(), usual: usual.trim(), count, of, offset: odd.offset },
+  }));
+};

package/src/detectors/custom.ts

@@ -1,4 +1,4 @@
-import type { Detector, Finding, Sentence, Span } from "../plugin.ts";
+import type { Detector, DetectorOptions, Finding, Sentence, Span } from "../plugin.ts";
 import { occurrencesOutside } from "../orthography.ts";
 import { tokenRuns } from "../custom/token-pattern.ts";
 import { joinedView, type JoinedView } from "../joined-view.ts";
@@ -43,13 +43,21 @@ const withoutBreaks = (source: string, start: number, end: number, breaks: reado
     .toReversed()
     .reduce((text, span) => `${text.slice(0, span.start - start)}${text.slice(span.end - start)}`, source.slice(start, end));
 
+/** A words rule's own words, or its word list's in the document's language: each entry's pattern, and its rewrite as the spelling to use. */
+const pairsOf = (
+  spec: { readonly words: readonly { readonly avoid: string; readonly use: string }[] },
+  options: DetectorOptions,
+): readonly { avoid: string; use: string }[] =>
+  spec.words.length > 0 ? spec.words : (options.lexicon ?? []).map((entry) => ({ avoid: entry.pattern, use: entry.rewrite ?? "" }));
+
 /** words: each spelling to avoid, outside the spelling to use (「ユーザ」 inside 「ユーザー」 is not reported). */
 export const customWords: Detector = (doc, options): Finding[] => {
   const spec = options.custom;
   if (spec?.type !== "words") return [];
+  const pairs = pairsOf(spec, options).filter((pair) => pair.avoid !== "" && pair.avoid !== pair.use);
   return doc.sentences.flatMap((sentence) => {
     const view = readAsWritten(sentence);
-    return spec.words.flatMap((pair) =>
+    return pairs.flatMap((pair) =>
       occurrencesOutside(view.text, pair.avoid, pair.use).map((start) => findingOf(hitAt(sentence, view, start, start + pair.avoid.length, pair.use))),
     );
   });

package/src/detectors/dangling-opener.ts

@@ -0,0 +1,74 @@
+import type { Detector, Finding, Lexicon, Token } from "../plugin.ts";
+
+/**
+ * 分詞で始めた句の後ろの主語が、形だけの it か there の文（Having reviewed the code, it is ready.）。
+ * 分詞の動作をしたのは書き手か読み手で、it ではない。読むのはこの形だけに絞り、主語が名詞の文は読まない。
+ * 読むのは -ing の分詞だけ。決まった言い方として読まれる分詞（Given, Based on, Generally speaking）は語彙表 dangling-participle の exempt が言う。
+ */
+
+export type DanglingOpener = { readonly opener: string; readonly subject: Token; readonly offset: number };
+
+/** 分詞の句として読む語の数の上限。長い句は読点の位置が当てにならない。 */
+const MAX_OPENER_TOKENS = 12;
+const BE = "be";
+const HAVE = "have";
+/** be の後ろで読点が来たら、it is … は挿入句（Testing the integration, it is worth noting, requires …）。 */
+const PARENTHETICAL_REACH = 4;
+
+const lower = (token: Token | undefined): string => token?.surface.toLowerCase() ?? "";
+
+/** -ing の分詞だけ。過去分詞の句（Configured with SSO, it is ready.）は it そのものを言うことが多い。 */
+const isPresentParticiple = (token: Token | undefined): boolean => token?.pos === "VERB" && token.features?.["VerbForm"] === "Ger";
+
+const lemmaOf = (token: Token | undefined): string => token?.lemma?.toLowerCase() ?? "";
+
+/** 文の頭が決まった言い方か。語彙表の語は空白で区切って、頭の語と順に比べる。 */
+const opensWithExempt = (tokens: readonly Token[], exempt: readonly string[]): boolean =>
+  exempt.some((phrase) => phrase.split(/\s+/u).every((word, at) => lower(tokens[at]) === word));
+
+/** 形だけの主語の後ろの be（it is / there are）、助動詞と be（it can be）、have と been（it has been）。 */
+const isBeAfter = (tokens: readonly Token[], at: number): boolean => {
+  const verb = tokens[at];
+  if (lemmaOf(verb) === BE) return true;
+  return (verb?.pos === "AUX" || lemmaOf(verb) === HAVE) && lemmaOf(tokens[at + 1]) === BE;
+};
+
+const isParenthetical = (tokens: readonly Token[], at: number): boolean => tokens.slice(at, at + PARENTHETICAL_REACH).some((token) => token.surface === ",");
+
+export const danglingOpenerIn = (
+  source: string,
+  tokens: readonly Token[],
+  subjects: ReadonlySet<string>,
+  exempt: readonly string[],
+): DanglingOpener | undefined => {
+  const [first] = tokens;
+  if (first === undefined || !isPresentParticiple(first) || opensWithExempt(tokens, exempt)) return undefined;
+  const comma = tokens.findIndex((token, at) => at > 0 && token.surface === ",");
+  const subject = tokens[comma + 1];
+  if (comma === -1 || comma > MAX_OPENER_TOKENS || subject === undefined || !subjects.has(lower(subject)) || !isBeAfter(tokens, comma + 2)) return undefined;
+  if (isParenthetical(tokens, comma + 3)) return undefined;
+  const last = tokens[comma - 1] ?? first;
+  return { opener: source.slice(first.span.start, last.span.end), subject, offset: first.span.start };
+};
+
+const patternsIn = (lexicon: Lexicon, group: string): string[] => lexicon.filter((entry) => entry.group === group).map((entry) => entry.pattern.toLowerCase());
+
+export const danglingOpener: Detector = (doc): Finding[] => {
+  const words = doc.lexicons["dangling-participle"] ?? [];
+  const subjects = new Set(patternsIn(words, "subject"));
+  const exempt = patternsIn(words, "exempt");
+  return doc.sentences.flatMap((sentence) => {
+    const found = sentence.embeddedLanguage === undefined ? danglingOpenerIn(doc.source, sentence.tokens ?? [], subjects, exempt) : undefined;
+    if (found === undefined) return [];
+    return [
+      {
+        rule: "",
+        severity: "info",
+        line: 0,
+        column: 0,
+        quote: sentence.text.trim(),
+        values: { opener: found.opener, subject: found.subject.surface, offset: found.offset },
+      },
+    ];
+  });
+};

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

@@ -0,0 +1,200 @@
+// A defined term used later in another form, and a long name used again after its short name was defined. Pure. The
+// definitions come from the document's structure tree (以下「甲」という, ("Seller")); which words may stand in a long
+// name is read from the tokens' parts of speech.
+import { definedTerms, usesOf, type BodyText, type DefinedTerm } from "../structure/definition-use.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { quoteAt } from "./structure-tree.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 }));
+
+const finding = (doc: ProseDocument, rule: string, offset: number, variant: string, values: Readonly<Record<string, string | number>>): Finding => ({
+  rule,
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: quoteAt(doc.source, offset),
+  values: { ...values, offset },
+  variant,
+});
+
+const OPENING_QUOTES = new Set(["「", "『", '"', "“"]);
+const CLOSING_QUOTES = new Set(["」", "』", '"', "”"]);
+/** A quoted term right before these is defined again (「X」とは, "X" means), which duplicate-definition reads. */
+const DEFINING_AFTER = /^(?:とは|という|\s+(?:means|shall mean|refers to|has the meaning))/u;
+/** The ending a use may carry past the term: a plural or a possessive (Services, Service's). */
+const WORD_ENDING = /^(?:e?s|['’]s?)/u;
+
+/** The first definition of each term, with the spans of all its definitions. */
+const firstDefinitions = (terms: readonly DefinedTerm[]): { readonly term: DefinedTerm; readonly spans: readonly Span[] }[] => {
+  const groups = new Map<string, { term: DefinedTerm; spans: Span[] }>();
+  terms.forEach((term) => {
+    const group = groups.get(term.term);
+    if (group === undefined) groups.set(term.term, { term, spans: [term.span] });
+    else group.spans.push(term.span);
+  });
+  return [...groups.values()];
+};
+
+/** A use of the term set in quotes again after its definition: 「本サービス」 where 本サービス was defined. */
+export const quotedUses = (source: string, term: string, uses: readonly number[], definedAt: number): number[] =>
+  uses.filter((offset) => {
+    const after = offset + term.length + (WORD_ENDING.exec(source.slice(offset + term.length, offset + term.length + 2))?.[0].length ?? 0);
+    return (
+      offset > definedAt &&
+      OPENING_QUOTES.has(source.charAt(offset - 1)) &&
+      CLOSING_QUOTES.has(source.charAt(after)) &&
+      !DEFINING_AFTER.test(source.slice(after + 1, after + 20))
+    );
+  });
+
+const UPPER_START = /^\p{Lu}/u;
+
+/**
+ * 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.
+ */
+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 : [];
+};
+
+/** How far back a sentence's start is looked for: past a few spaces to the mark before them. */
+const LOOK_BACK = 40;
+const SENTENCE_END = new Set([".", "!", "?", ":"]);
+
+/** A sentence's first word is capitalised whatever it is, so only a lower-case use inside a sentence counts. */
+const isSentenceStart = (source: string, offset: number): boolean => {
+  const before = source.slice(Math.max(0, offset - LOOK_BACK), offset);
+  const text = before.trimEnd();
+  return (offset < LOOK_BACK && text === "") || before.slice(text.length).includes("\n") || SENTENCE_END.has(text.at(-1) ?? "");
+};
+
+/** 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 VERBAL = new Set(["VERB", "AUX"]);
+
+/** 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 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.
+  const before = tokens[at - 1];
+  const afterSubject = before?.pos === "PRON" && before.features?.["Poss"] !== "Yes";
+  return VERBAL.has(token.pos) || afterSubject;
+};
+
+export const definedTermForm: Detector = (doc, options): Finding[] => {
+  if (doc.structure === undefined) return [];
+  const texts = bodyOf(doc);
+  return firstDefinitions(definedTerms(doc.structure)).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 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];
+  });
+};
+
+/** The words a long name is made of: nouns and names (株式会社 みなと 製作所, Acme Corporation), and the marks inside one. */
+const NAME_PARTS = new Set(["NOUN", "PROPN", "NUM"]);
+const NAME_MARKS = new Set(["・", "&", "＆", ".", ","]);
+/** A long name shorter than this (法律, Customer) is an ordinary word, used in its own sense again. */
+const MIN_NAME_CHARS = 4;
+/** In English a long name has two words or more (Acme Corporation); one capitalised word is the term's own kind of word. */
+const MIN_NAME_WORDS = 2;
+const LATIN = /\p{Script=Latin}/u;
+
+const isNamePart = (token: Token): boolean => NAME_PARTS.has(token.pos) || NAME_MARKS.has(token.surface);
+
+/** The long name written right before an inline definition: the run of name words that ends at its opening bracket. */
+export const nameBefore = (sentence: Sentence, bracket: number): string | undefined => {
+  const tokens = (sentence.tokens ?? []).filter((token) => token.span.end <= bracket);
+  const firstOfRun = tokens.findLastIndex((token) => !isNamePart(token)) + 1;
+  if (isModifier(tokens[firstOfRun - 1])) return undefined;
+  const run = tokens.slice(firstOfRun).filter((token, index, all) => index > 0 || !NAME_MARKS.has(token.surface) || all.length === 1);
+  const first = run[0];
+  const end = run.at(-1);
+  if (first === undefined || end === undefined || bracket - end.span.end > 1) return undefined;
+  const name = withoutTrailingMarks(sentence.text.slice(first.span.start - sentence.span.start, end.span.end - sentence.span.start));
+  const words = name.split(/\s+/u).length;
+  return [...name].length < MIN_NAME_CHARS || (LATIN.test(name) && words < MIN_NAME_WORDS) ? undefined : name;
+};
+
+/**
+ * A word that narrows the name before it: an article, an adjective, a verb, or の (妊娠中の女性従業員, the Beta Preview, 本利用規約).
+ * The words then name a kind of thing the definition picks out, not one party, and are used in their own sense again.
+ */
+const MODIFIERS = new Set(["DET", "ADJ", "VERB", "AUX"]);
+const isModifier = (token: Token | undefined): boolean => token !== undefined && (MODIFIERS.has(token.pos) || token.surface === "の");
+
+const TRAILING_MARKS = new Set([",", ".", " "]);
+
+const withoutTrailingMarks = (text: string): string => {
+  const chars = [...text];
+  return chars.slice(0, chars.findLastIndex((char) => !TRAILING_MARKS.has(char)) + 1).join("");
+};
+
+/** Where the inline definition's bracket opens: （以下「甲」という。） or ("Seller"). */
+const bracketBefore = (source: string, definition: Span): number => {
+  const before = source.slice(Math.max(0, definition.start - 2), definition.start + 1);
+  const at = Math.max(before.lastIndexOf("（"), before.lastIndexOf("("));
+  return at === -1 ? -1 : Math.max(0, definition.start - 2) + at;
+};
+
+export type RepeatedName = { readonly offset: number; readonly name: string; readonly term: string; readonly line: number };
+
+/** A line that holds the short name too (甲 株式会社みなと) or little else than the long name: a signature block names both. */
+const isNameLine = (source: string, offset: number, name: string, term: string): boolean => {
+  const start = source.lastIndexOf("\n", offset - 1) + 1;
+  const end = source.indexOf("\n", offset);
+  const line = source.slice(start, end === -1 ? source.length : end).trim();
+  const SLACK = 12;
+  return line.includes(term) || [...line].length <= [...name].length + SLACK;
+};
+
+/** A name inside a longer word (東京大学 in 東京大学大学院, Acme in Acmeware) is part of another name. */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+const standsAlone = (source: string, offset: number, name: string): boolean =>
+  !WORD_CHAR.test(source.charAt(offset - 1)) && !WORD_CHAR.test(source.charAt(offset + name.length));
+
+/**
+ * Each use of a long name after the definition gave it a short name, outside a signature line. A name that is itself a
+ * defined term (during each Subscription Term ("Permitted Use")) is a clause's last words, not the thing being named.
+ */
+export const repeatedNames = (doc: ProseDocument, terms: readonly DefinedTerm[]): RepeatedName[] => {
+  const defined = new Set(terms.map((term) => term.term));
+  return terms
+    .filter((term) => term.inline)
+    .flatMap((term) => {
+      const bracket = bracketBefore(doc.source, term.span);
+      const sentence = doc.sentences.find((candidate) => candidate.span.start <= bracket && bracket < candidate.span.end);
+      const name = sentence === undefined || bracket === -1 ? undefined : nameBefore(sentence, bracket);
+      if (name === undefined || name === term.term || term.term.includes(name) || defined.has(name)) return [];
+      const pattern = new RegExp(escapeRegExp(name), "gu");
+      return doc.sentences
+        .filter((later) => later.span.start > term.span.end)
+        .flatMap((later) => [...later.text.matchAll(pattern)].map((match) => later.span.start + match.index))
+        .filter((offset) => standsAlone(doc.source, offset, name) && !isNameLine(doc.source, offset, name, term.term))
+        .map((offset) => ({ offset, name, term: term.term, line: term.line }));
+    });
+};
+
+export const definedNameRepeated: Detector = (doc): Finding[] =>
+  doc.structure === undefined
+    ? []
+    : repeatedNames(doc, definedTerms(doc.structure)).map((repeated) =>
+        finding(doc, "defined-name-repeated", repeated.offset, "name", { name: repeated.name, term: repeated.term, line: repeated.line }),
+      );