chaffjs 0.28.0 → 0.29.0

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

@@ -0,0 +1,71 @@
+import type { Detector, Finding, Lexicon, LexiconEntry, Token } from "../plugin.ts";
+
+// A helper verb or formal noun written in kanji where a style writes it in kana (見て下さい → 見てください). The word
+// list says which words and how each is told apart from its main use (資料を下さい, 本を置く, 事が起きる); this file
+// reads that off the tagger's marks. Pure: the tokens and the word list come in.
+
+export type KanaSpelling = { readonly written: string; readonly preferred: string; readonly offset: number };
+
+const TE_FORM = new Set(["て", "で"]);
+
+const followsTeForm = (previous: Token | undefined): boolean => previous?.pos === "SCONJ" && TE_FORM.has(previous.surface);
+
+const isBound = (token: Token): boolean => token.features?.["Bound"] === "Yes";
+
+const isFormalNoun = (token: Token): boolean => token.features?.["NounType"] === "Dependent";
+
+const TOPIC = "は";
+const CASE_NI = "に";
+
+/** 〜時は and 〜時には: a condition. 〜時から, 〜時に (a point in time) are not. */
+const beforeTopic = (tokens: readonly Token[], index: number): boolean =>
+  tokens[index + 1]?.surface === TOPIC || (tokens[index + 1]?.surface === CASE_NI && tokens[index + 2]?.surface === TOPIC);
+
+/** Whether the word at index is used as the list's group says: a helper after て, a formal noun, a condition (〜時は, 〜時には). */
+const usedAsFunctionWord = (group: string | undefined, tokens: readonly Token[], index: number): boolean => {
+  const token = tokens[index];
+  if (token === undefined) return false;
+  if (group === "auxiliary") return isBound(token) || followsTeForm(tokens[index - 1]);
+  if (group === "after-te") return followsTeForm(tokens[index - 1]);
+  if (group === "formal-noun") return isFormalNoun(token);
+  if (group === "conditional") return isFormalNoun(token) && beforeTopic(tokens, index);
+  return false;
+};
+
+const KANJI = /^\p{Script=Han}+/u;
+
+/** The written word with its kanji stem in kana: 下さい with 下さる → くださる gives ください. Undefined when the entry or the word does not fit. */
+export const inKana = (written: string, entry: LexiconEntry): string | undefined => {
+  const stem = KANJI.exec(entry.pattern)?.[0];
+  const rewrite = entry.rewrite;
+  if (stem === undefined || rewrite === undefined || !written.startsWith(stem)) return undefined;
+  const okurigana = entry.pattern.slice(stem.length);
+  if (!rewrite.endsWith(okurigana)) return undefined;
+  return `${rewrite.slice(0, rewrite.length - okurigana.length)}${written.slice(stem.length)}`;
+};
+
+const entryFor = (token: Token, lexicon: Lexicon): LexiconEntry | undefined =>
+  lexicon.find((entry) => entry.pattern === token.lemma && token.surface.startsWith(entry.pattern.charAt(0)));
+
+/** Each word in the tokens that the word list writes in kana, used as its group says. */
+export const kanaSpellingsIn = (tokens: readonly Token[], lexicon: Lexicon): KanaSpelling[] =>
+  tokens.flatMap((token, index) => {
+    const entry = entryFor(token, lexicon);
+    if (entry === undefined || !usedAsFunctionWord(entry.group, tokens, index)) return [];
+    const preferred = inKana(token.surface, entry);
+    return preferred === undefined ? [] : [{ written: token.surface, preferred, offset: token.span.start }];
+  });
+
+export const kanaFunctionWord: Detector = (doc, options): Finding[] => {
+  const lexicon = options.lexicon ?? [];
+  const found = doc.sentences.flatMap((sentence) => kanaSpellingsIn(sentence.tokens ?? [], lexicon).map((spelling) => ({ sentence, spelling })));
+  if (found.length < options.limit) return [];
+  return found.map(({ sentence, spelling }) => ({
+    rule: "",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: sentence.text.trim(),
+    values: { matched: spelling.written, preferred: spelling.preferred, offset: spelling.offset },
+  }));
+};

package/src/detectors/line-amount.ts

@@ -0,0 +1,33 @@
+// line-amount-mismatch: the reading half. The column names come from the language's lexicons (quantity-column,
+// unit-price-column, line-amount-column), the units from rate-unit and per-unit-mark; the tables are read from the prose with its tables put back, so code is not.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { lineAmountMismatches, type LineAmountWords } from "../structure/line-amount.ts";
+import type { UnitWord } from "../structure/line-amount-unit.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAt } from "./structure-tree.ts";
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+const unitWordsOf = (doc: ProseDocument, ...lexicons: string[]): UnitWord[] =>
+  lexicons.flatMap((lexicon) =>
+    (doc.lexicons[lexicon] ?? []).flatMap((entry) => (entry.group === undefined ? [] : [{ pattern: entry.pattern, unit: entry.group }])),
+  );
+
+const wordsOf = (doc: ProseDocument): LineAmountWords => ({
+  quantity: patternsOf(doc, "quantity-column"),
+  unitPrice: patternsOf(doc, "unit-price-column"),
+  amount: patternsOf(doc, "line-amount-column"),
+  units: unitWordsOf(doc, "rate-unit"),
+  perUnitMarks: unitWordsOf(doc, "per-unit-mark"),
+  headerUnits: unitWordsOf(doc, "quantity-column", "unit-price-column"),
+});
+
+export const lineAmount: Detector = (doc): Finding[] =>
+  lineAmountMismatches(proseAndTablesOf(doc), wordsOf(doc)).map((issue) => ({
+    rule: "line-amount-mismatch",
+    severity: "error",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, issue.offset),
+    values: { ...issue.values, offset: issue.offset },
+  }));

package/src/detectors/location-pointer.ts

@@ -0,0 +1,30 @@
+// Whether a sentence names where its content lives: a link, a web address, or a file in code. Pure.
+import { bareUrls } from "../bare-url.ts";
+import type { Span } from "../plugin.ts";
+
+/** A code span: a run of backticks, then the same run closing it, neither run touching another backtick. */
+const CODE_SPAN = /(?<!`)(`+)(?!`)(.+?)(?<!`)\1(?!`)/gsu;
+
+/** A link to a place on the same page (`[text](#id)`): the reader is already on that page. */
+const IN_PAGE_LINK = /\]\(\s*<?#[^)]*\)$/u;
+
+/** A page a reader opens, as a file name: README.md, guide.html, spec.pdf. A source file (main.go) names code, not a page. */
+const PAGE_FILE = /\.(?:md|markdown|mdx|txt|rst|adoc|html?|pdf)$/iu;
+
+const SEPARATOR = /[/\\]/u;
+const LETTER = /\p{L}/u;
+
+/** Code that is a path (docs/api.md, ./config, src\index) or a page file, not an identifier or an expression. */
+const isLocationCode = (code: string): boolean => {
+  const written = code.trim();
+  if (written.length === 0 || /\s/u.test(written) || !LETTER.test(written)) return false;
+  return SEPARATOR.test(written) || PAGE_FILE.test(written);
+};
+
+/** The sentence as written names a web address or, in code, a path or a page file. */
+export const namesLocation = (written: string): boolean =>
+  bareUrls(written).length > 0 || [...written.matchAll(CODE_SPAN)].some((match) => isLocationCode(match[2] ?? ""));
+
+/** One of the links written in the sentence's span leads off the page. */
+export const holdsLink = (source: string, sentence: Span, links: readonly Span[]): boolean =>
+  links.some((link) => link.start < sentence.end && link.end > sentence.start && !IN_PAGE_LINK.test(source.slice(link.start, link.end)));

package/src/detectors/mark-shape.ts

@@ -147,7 +147,24 @@ const reportFrom = (hits: readonly Hit[], limit: number): Finding[] => (hits.len
 /** A spaced hyphen or a double hyphen between words, standing for a dash ("late - very late", "late--very late"). */
 const HYPHEN_DASH = /(?<=[\p{L},;)]) -{1,2} (?=[\p{L}(])|(?<=\p{L})--(?=\p{L})/gu;
 
-export const hyphenDash: Detector = (doc, options): Finding[] => reportFrom(hitsOf(ownSentences(doc), HYPHEN_DASH), options.limit);
+/** A dash set as a character (an em dash, an en dash). */
+const TRUE_DASH = /[—–]/u;
+const DOUBLE_HYPHEN = "--";
+
+/**
+ * Whether the hit is a double hyphen in a document that sets no dash as a character: there "--" is how the document types its
+ * dash (plain-text standards, typewriter text, Markdown that a typographer turns into a dash), not a hyphen standing in for one.
+ */
+const isTypedDash = (hit: Hit, setsDashes: boolean): boolean => !setsDashes && hit.matched === DOUBLE_HYPHEN;
+
+export const hyphenDash: Detector = (doc, options): Finding[] => {
+  const sentences = ownSentences(doc);
+  const setsDashes = sentences.some((sentence) => TRUE_DASH.test(sentence.text));
+  return reportFrom(
+    hitsOf(sentences, HYPHEN_DASH).filter((hit) => !isTypedDash(hit, setsDashes)),
+    options.limit,
+  );
+};
 
 /** Every way of writing an abbreviation with some of its periods dropped but not all (e.g. → e.g, eg.). */
 export const partialForms = (abbreviation: string): string[] => {

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

@@ -0,0 +1,25 @@
+// nado-closed-list: 等, など or etc. on a list a limit closes (自転車等に限ります, only A, B, etc.), read sentence by sentence
+// (nado-closed-list.ts). The tokens are moved to the sentence's own offsets before they are read.
+import { closedListWordsOf, openWordsOnClosedLists } from "../nado-closed-list.ts";
+import type { Detector, Finding, Sentence, Token } from "../plugin.ts";
+
+const sentenceTokens = (sentence: Sentence): Token[] =>
+  (sentence.tokens ?? []).map((token) => ({
+    ...token,
+    span: { start: token.span.start - sentence.span.start, end: token.span.end - sentence.span.start },
+  }));
+
+export const nadoClosedList: Detector = (doc, options): Finding[] => {
+  const words = closedListWordsOf(options.lexicon ?? []);
+  if (words.open.length === 0) return [];
+  return doc.sentences.flatMap((sentence) =>
+    openWordsOnClosedLists(sentence.text, sentenceTokens(sentence), words).map((hit) => ({
+      rule: "",
+      severity: "info",
+      line: 0,
+      column: 0,
+      quote: sentence.text.trim(),
+      values: { open: hit.open, limit: hit.limit, offset: sentence.span.start + hit.offset },
+    })),
+  );
+};

package/src/detectors/name-variant.ts

@@ -1,25 +1,118 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { mentionsIn, nameVariants, suffixedNamesIn, type VariantChars } from "../name-variants.ts";
+import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, type NameMention, type VariantChars } from "../name-variants.ts";
+import { nameCueAt, type NameCues } from "../name-cue.ts";
 import { quoteAt } from "./structure-tree.ts";
+import { companyMentionsIn, companyVariants, type CompanyForm, type IsProper } from "../company-names.ts";
+import { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
+import type { Token } from "../plugin.ts";
 
-// 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
+// 人の名前と読ませる敬称（様、さん）は語彙表 person-suffix、人を指す前置き（担当の）は person-lead、名前のすぐ後ろに来る語
+// （です、まで）は name-particle、字体の違う同じ字（斎・斉・齋）は name-variant-char が組（group）ごとに言う。
 
 const variantCharsOf = (doc: ProseDocument): VariantChars =>
   new Map((doc.lexicons["name-variant-char"] ?? []).flatMap((entry): [string, string][] => (entry.group === undefined ? [] : [[entry.pattern, entry.group]])));
 
+const patternsOf = (doc: ProseDocument, id: string): string[] => (doc.lexicons[id] ?? []).map((entry) => entry.pattern);
+
+/** 会社の形の語（株式会社、Inc）は語彙表 company-form が、同じ形の組（group）と名前のどちら側に立つか（position）とともに言う。 */
+const companyFormsOf = (doc: ProseDocument): CompanyForm[] =>
+  (doc.lexicons["company-form"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern, position: entry.position }));
+
+/** source の上の範囲に、品詞解析が固有名詞と読んだ語が掛かるか。 */
+const properOf = (doc: ProseDocument): IsProper => {
+  const spans = doc.sentences.flatMap((sentence) => (sentence.tokens ?? []).filter((token) => token.pos === "PROPN").map((token) => token.span));
+  return (start, end) => spans.some((span) => span.start < end && start < span.end);
+};
+
+/** 場所の名前の終わりに立つ語（口、駅、Street、St.）は語彙表 place-word が、同じ語の別の書き方の組（group）とともに言う。 */
+const placeWordsOf = (doc: ProseDocument): PlaceWord[] =>
+  (doc.lexicons["place-word"] ?? []).map((entry) => ({ pattern: entry.pattern, group: entry.group ?? entry.pattern }));
+
+/** 名前の頭に立たない語の品詞（The、at、and）。 */
+const FUNCTION_POS: ReadonlySet<string> = new Set(["DET", "ADP", "PRON", "CCONJ", "SCONJ", "AUX", "PART"]);
+
+const tokensOf = (doc: ProseDocument): Token[] => doc.sentences.flatMap((sentence) => sentence.tokens ?? []);
+
+/** 場所の名前の語の数の上限。名前の読みを探す範囲。 */
+const MAX_PLACE_TOKENS = 20;
+
+/** 範囲をちょうど覆う語の読みをつないだもの。記号の語は読まない。覆えないか、読めない語があれば無い。 */
+const readingIn = (tokens: readonly Token[], startAt: ReadonlyMap<number, number>, start: number, end: number): string | undefined => {
+  const first = startAt.get(start);
+  if (first === undefined) return undefined;
+  const window = tokens.slice(first, first + MAX_PLACE_TOKENS);
+  const covering = window.slice(0, window.findIndex((token) => token.span.end >= end) + 1);
+  if (covering.at(-1)?.span.end !== end) return undefined;
+  const readings = covering.filter((token) => token.pos !== "PUNCT").map((token) => token.reading);
+  return readings.every((reading) => reading !== undefined && reading !== "") ? readings.join("") : undefined;
+};
+
+const placeReaderOf = (doc: ProseDocument): PlaceReader => {
+  const tokens = tokensOf(doc);
+  const startAt = new Map(tokens.map((token, index) => [token.span.start, index]));
+  const functionStarts = new Set(tokens.filter((token) => FUNCTION_POS.has(token.pos)).map((token) => token.span.start));
+  return {
+    properWords: (start, end) => {
+      const first = startAt.get(start);
+      const window = first === undefined ? [] : tokens.slice(first, first + MAX_PLACE_TOKENS);
+      return window.filter((token) => token.pos === "PROPN" && token.span.start < end).map((token) => token.span);
+    },
+    joiners: new Set(patternsOf(doc, "place-name-joiner")),
+    isFunctionWord: (start) => functionStarts.has(start),
+    readingOf: (start, end) => readingIn(tokens, startAt, start, end),
+  };
+};
+
+type Reported = { readonly offset: number; readonly name: string; readonly usual: string; readonly kind: string };
+
+const overlapsAny = (reported: readonly Reported[], offset: number, length: number): boolean =>
+  reported.some((other) => other.offset < offset + length && offset < other.offset + other.name.length);
+
+/** 会社の名前の書き分け。名前の見方がすでに指した所と重なるものは除く。 */
+const companyFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
+  companyVariants(companyMentionsIn(prose, companyFormsOf(doc), properOf(doc)))
+    .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
+    .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind: kind === "spelling" ? kind : `company-${kind}` }));
+
+/** 場所の名前の書き分け。人や会社の名前の見方がすでに指した所と重なるものは除く。 */
+const placeFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] =>
+  placeVariants(placeMentionsIn(prose, placeWordsOf(doc), placeReaderOf(doc)))
+    .filter(({ mention }) => !overlapsAny(reported, mention.offset, mention.surface.length))
+    .map(({ mention, usual, kind }) => ({ offset: mention.offset, name: mention.surface, usual, kind }));
+
+/** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。 */
+const nameMentionsOf = (doc: ProseDocument, prose: string, chars: VariantChars): NameMention[] => {
+  const cues: NameCues = { leads: patternsOf(doc, "person-lead"), suffixes: patternsOf(doc, "person-suffix"), particles: patternsOf(doc, "name-particle") };
+  const tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, cues.suffixes));
+  const taggedOrSuffixed = [...tagged, ...suffixedNamesIn(prose, cues.suffixes, chars, tagged)];
+  return [...taggedOrSuffixed, ...cuedNamesIn(prose, cues, chars, taggedOrSuffixed)]
+    .map((mention): NameMention => {
+      const cue = mention.cue ?? nameCueAt(prose, mention.offset, mention.surface, cues);
+      return cue === undefined ? mention : { ...mention, cue };
+    })
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（GitHub と Github、山田太郎 と 山田太朗）。少ないほうを指す。 */
 export const nameVariant: Detector = (doc): Finding[] => {
-  const suffixes = (doc.lexicons["person-suffix"] ?? []).map((entry) => entry.pattern);
+  const prose = doc.prose ?? doc.source;
   const chars = variantCharsOf(doc);
-  const tagged = doc.sentences.flatMap((sentence) => mentionsIn(sentence.tokens ?? [], doc.source, suffixes));
-  const mentions = [...tagged, ...suffixedNamesIn(doc.prose ?? doc.source, suffixes, chars, tagged)].toSorted((left, right) => left.offset - right.offset);
-  return nameVariants(mentions, chars).map(({ mention, usual, kind }) => ({
-    rule: "",
-    severity: "warning",
-    line: 0,
-    column: 0,
-    quote: quoteAt(doc.source, mention.offset),
-    values: { name: mention.surface, usual, offset: mention.offset },
-    variant: kind,
+  const names = nameVariants(nameMentionsOf(doc, prose, chars), chars).map(({ mention, usual, kind }): Reported => ({
+    offset: mention.offset,
+    name: mention.surface,
+    usual,
+    kind,
   }));
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  return [...namesAndCompanies, ...placeFindings(doc, prose, namesAndCompanies)]
+    .toSorted((left, right) => left.offset - right.offset)
+    .map(({ offset, name, usual, kind }) => ({
+      rule: "",
+      severity: "warning",
+      line: 0,
+      column: 0,
+      quote: quoteAt(doc.source, offset),
+      values: { name, usual, offset },
+      variant: kind,
+    }));
 };

package/src/detectors/next-word.ts

@@ -1,5 +1,6 @@
 import type { Detector, Finding, Lexicon, Sentence, Token } from "../plugin.ts";
 import { densityFindings } from "./ai-phrasing.ts";
+import { entryEndsAt } from "./lexicon-match.ts";
 
 /**
  * The word kinds an article can stand before. A conjunction, a preposition or a verb after "a" is the letter a ("option A
@@ -127,30 +128,76 @@ const ADJECTIVE = "ADJ";
 
 type Intensified = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
 
-type IntensifierWords = { readonly intensifiers: ReadonlySet<string>; readonly exceptions: ReadonlySet<string> };
+type IntensifierWords = {
+  readonly intensifiers: Lexicon;
+  readonly exceptions: ReadonlySet<string>;
+  /** Words after a noun that make it an adjective (便利な, 静かだ). Japanese only: its adjectival nouns are tagged as nouns. */
+  readonly copulas: ReadonlySet<string>;
+};
+
+/** An adjective, or a noun the lexicon's copula, an auxiliary (not the particle で), makes one: 便利 in 便利な. */
+const isAdjectiveAt = (tokens: readonly Token[], at: number, copulas: ReadonlySet<string>): boolean => {
+  const token = tokens[at];
+  if (token?.pos === ADJECTIVE) return true;
+  const after = tokens[at + 1];
+  return token?.pos === "NOUN" && after?.pos === "AUX" && copulas.has(after.surface);
+};
+
+const isBlank = (token: Token): boolean => token.surface.trim() === "";
+
+/** For each token, the index of the last non-blank token before it, or -1: one pass, so a long sentence is not rescanned per token. */
+const previousWords = (tokens: readonly Token[]): number[] =>
+  tokens.reduce<{ readonly before: number[]; readonly last: number }>(
+    ({ before, last }, token, index) => {
+      before.push(last);
+      return { before, last: isBlank(token) ? last : index };
+    },
+    { before: [], last: -1 },
+  ).before;
+
+/** The intensifier that ends at `end` (past a line break: 非常に / 危険), as the index of its first token. */
+const intensifierStart = (tokens: readonly Token[], end: number, intensifiers: Lexicon): number | undefined => {
+  const entry = intensifiers.find((candidate) => entryEndsAt(tokens, candidate, end));
+  return entry === undefined ? undefined : end - (entry.tokens?.length ?? 1);
+};
+
+/** The intensifier and the adjective as words: "very important" in a spaced language, 非常に危険 in one measured in characters. */
+const matchedText = (tokens: readonly Token[], start: number, at: number, spaced: boolean): string =>
+  tokens
+    .slice(start, at + 1)
+    .filter((token) => !isBlank(token))
+    .map((token) => token.surface)
+    .join(spaced ? " " : "");
 
 /** The lexicon's intensifier right before an adjective ("very important"), not before an excepted word ("the very first"). */
-const intensifiedIn = (source: string, sentence: Sentence, words: IntensifierWords): Intensified[] => {
+const intensifiedIn = (source: string, sentence: Sentence, words: IntensifierWords, spaced: boolean): Intensified[] => {
   const tokens = sentence.tokens ?? [];
-  return tokens.flatMap((token, at) => {
-    const next = tokens[at + 1];
-    if (next === undefined || !words.intensifiers.has(token.surface.toLowerCase()) || next.pos !== ADJECTIVE) return [];
-    if (!adjacent(source, token, next)) return [];
-    return words.exceptions.has(next.surface.toLowerCase()) ? [] : [{ sentence, matched: `${token.surface} ${next.surface}`, offset: token.span.start }];
+  const before = previousWords(tokens);
+  return tokens.flatMap((next, at) => {
+    const lastAt = before[at] ?? -1;
+    const start = intensifierStart(tokens, lastAt + 1, words.intensifiers);
+    const first = start === undefined ? undefined : tokens[start];
+    const last = tokens[lastAt];
+    if (start === undefined || first === undefined || last === undefined || !isAdjectiveAt(tokens, at, words.copulas)) return [];
+    if (!adjacent(source, last, next) || words.exceptions.has(next.surface.toLowerCase())) return [];
+    return [{ sentence, matched: matchedText(tokens, start, at, spaced), offset: first.span.start }];
   });
 };
 
 const EXCEPTIONS = "very-exception";
+const COPULAS = "very-copula";
 
 /** "very" + adjective, dense for the document's length: each one leans on "very" instead of a stronger word. */
 export const intensifiedAdjective: Detector = (doc, options): Finding[] => {
   const words = {
-    intensifiers: new Set((options.lexicon ?? []).map((entry) => entry.pattern)),
+    intensifiers: options.lexicon ?? [],
     exceptions: new Set((doc.lexicons[EXCEPTIONS] ?? []).map((entry) => entry.pattern)),
+    copulas: new Set((doc.lexicons[COPULAS] ?? []).map((entry) => entry.pattern)),
   };
+  const spaced = doc.lengthUnit !== "char";
   return densityFindings(
     doc,
-    doc.sentences.flatMap((sentence) => intensifiedIn(doc.source, sentence, words)),
+    doc.sentences.flatMap((sentence) => intensifiedIn(doc.source, sentence, words, spaced)),
     options.limit,
   );
 };

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

@@ -0,0 +1,43 @@
+// number-word-figure-mismatch: a number in words and its figure in brackets disagree (structure/number-word-figure.ts).
+// The number words are the lexicon number-word; the marks around the figure are currency-notation's and the unit words of
+// number-word; the words of scale inside the bracket ($5 million) are amount-multiplier's.
+import type { Detector, Finding, ProseDocument } from "../plugin.ts";
+import { wordFigureSlips, type NumberVocabulary, type NumberWord, type NumberWordKind } from "../structure/number-word-figure.ts";
+import { proseAndTablesOf } from "../table-text.ts";
+import { quoteAround } from "./quote-around.ts";
+
+const KINDS: readonly NumberWordKind[] = ["digit", "place", "scale", "joiner", "lead", "unit"];
+
+const numberWordsOf = (doc: ProseDocument): NumberWord[] =>
+  (doc.lexicons["number-word"] ?? []).flatMap((entry) => {
+    const kind = KINDS.find((candidate) => candidate === entry.group);
+    return kind === undefined ? [] : [{ word: entry.pattern, kind, value: entry.weight ?? 0 }];
+  });
+
+export const vocabularyOf = (doc: ProseDocument): NumberVocabulary => {
+  const words = numberWordsOf(doc);
+  const currencies = doc.lexicons["currency-notation"] ?? [];
+  const units = words.filter((word) => word.kind === "unit").map((word) => word.word);
+  return {
+    words,
+    marksBefore: currencies.filter((entry) => entry.position === "before").map((entry) => entry.pattern),
+    marksAfter: [...currencies.filter((entry) => entry.position === "after").map((entry) => entry.pattern), ...units],
+    multipliers: (doc.lexicons["amount-multiplier"] ?? []).flatMap((entry) =>
+      entry.weight === undefined ? [] : [{ word: entry.pattern, value: entry.weight }],
+    ),
+  };
+};
+
+const NUMBER_FORMAT = new Intl.NumberFormat("en-US", { maximumFractionDigits: 2 });
+
+export const numberWordFigure: Detector = (doc): Finding[] => {
+  const text = proseAndTablesOf(doc);
+  return wordFigureSlips(text, vocabularyOf(doc)).map((slip) => ({
+    rule: "number-word-figure-mismatch",
+    severity: "warning",
+    line: 0,
+    column: 0,
+    quote: quoteAround(text, slip.offset, slip.end),
+    values: { written: slip.written, words: NUMBER_FORMAT.format(slip.words), figure: NUMBER_FORMAT.format(slip.figure), offset: slip.offset },
+  }));
+};

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

@@ -0,0 +1,192 @@
+// A duty that happens at a point in time (pay, deliver, return, notify; 支払う, 提出する, 通知する) written with no time at
+// all, in a contract that gives most of its other duties a limit: by when must it be done? The drafter decides whether
+// duties carry limits, so only the minority in one document is pointed at, as vague-deadline does. A sentence holding
+// a vague limit (promptly) is vague-deadline's; one stating an amount (pays a fee of $9,000) sets a price, and its
+// timing is another clause's. The words come from the language package's word lists: timed-duty (the act),
+// duty-marker (shall, will), duty-ending (う, するものとする: what may follow a Japanese act at the sentence end),
+// stated-deadline (by the, までに) with concrete-deadline and vague-deadline, deadline-permission and currency-notation. Pure.
+import { quoteAt } from "./structure-tree.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { grantsRight, statesConcrete, vagueIn } from "./vague-deadline.ts";
+import type { Detector, Finding, LexiconEntry, ProseDocument } from "../plugin.ts";
+
+export type UntimedDuty = { readonly offset: number; readonly act: string };
+
+/** sameLine: the sentence goes on the line of the one before it (no line break between them). */
+type Text = { readonly start: number; readonly text: string; readonly sameLine?: boolean };
+
+/** What the word lists give the decision. */
+export type DutyWords = {
+  readonly acts: readonly string[];
+  readonly markers: readonly string[];
+  /** Words that, between the marker and the act, make the duty one not to act (will not submit). */
+  readonly negations: readonly string[];
+  readonly endings: readonly string[];
+  /** Phrases or frames that give a sentence a limit: concrete-deadline and stated-deadline. */
+  readonly limits: readonly string[];
+  /** Words that, where they stand, are no limit though a limit's words are in them (解除の日までの委託料: までの). */
+  readonly notLimits: readonly string[];
+  readonly vague: readonly string[];
+  /** Words that send the reader to other terms for how the act is done (according to the terms in the Order Form). */
+  readonly deferrals: readonly string[];
+  readonly permissions: readonly LexiconEntry[];
+  readonly currencies: readonly LexiconEntry[];
+};
+
+const LATIN = /\p{Script=Latin}/u;
+const LETTER = /\p{L}/u;
+const DIGIT = /\p{Nd}/u;
+const SENTENCE_MARKS = new Set(["。", "．", ".", "!", "?", "！", "？", ";", ":"]);
+/** How many words an aside between the duty marker and the act may hold: "shall, at its option, return". */
+const MARKER_REACH_WORDS = 4;
+/** How far before an amount's trailing mark its number may end (88万円, 1,000 円). */
+const AMOUNT_REACH = 3;
+
+const withoutEnding = (text: string): string => {
+  const chars = [...text.trimEnd()];
+  const last = chars.findLastIndex((char) => !SENTENCE_MARKS.has(char) && char.trim() !== "");
+  return chars.slice(0, last + 1).join("");
+};
+
+const latinWords = (lower: string): { readonly word: string; readonly at: number }[] =>
+  [...lower.matchAll(/[\p{L}']+/gu)].map((match) => ({ word: match[0], at: match.index }));
+
+/** The act a Latin-script duty binds: an act word within reach after a duty marker (shall return, will notify). */
+const latinActAt = (lower: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined => {
+  const tokens = latinWords(lower);
+  const markerWords = words.markers.map((marker) => marker.toLowerCase().split(/\s+/u));
+  const markerEnds = tokens.flatMap((_, index) =>
+    markerWords.filter((parts) => parts.every((part, offset) => tokens[index + offset]?.word === part)).map((parts) => index + parts.length),
+  );
+  const acts = new Set(words.acts.map((act) => act.toLowerCase()));
+  const negations = new Set(words.negations.map((word) => word.toLowerCase()));
+  return markerEnds
+    .flatMap((end) => {
+      const reach = tokens.slice(end, end + MARKER_REACH_WORDS);
+      const act = reach.findIndex((token) => acts.has(token.word));
+      const found = reach[act];
+      const marker = tokens[end - 1];
+      if (found === undefined || marker === undefined || reach.slice(0, act).some((token) => negations.has(token.word))) return [];
+      // The act is the verb right after the marker, or after an aside set off by a comma ("shall, at its option, return");
+      // a later act word is an object ("shall send each invoice").
+      const aside = lower
+        .slice(marker.at + marker.word.length, found.at)
+        .trimStart()
+        .startsWith(",");
+      return act === 0 || aside ? [found] : [];
+    })
+    .map((token) => ({ act: token.word, at: token.at }))[0];
+};
+
+/** The act a duty written as the sentence's last predicate binds (支払う, 通知するものとする, 通知します). */
+const endingActAt = (text: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined => {
+  const ending = withoutEnding(text);
+  const act = words.acts.find((stem) => stem !== "" && words.endings.some((tail) => ending.endsWith(`${stem}${tail}`)));
+  if (act === undefined) return undefined;
+  return { act, at: ending.lastIndexOf(act) };
+};
+
+const actIn = (text: string, words: DutyWords): { readonly act: string; readonly at: number } | undefined =>
+  words.acts.some((act) => LATIN.test(act)) ? latinActAt(text.toLowerCase(), words) : endingActAt(text, words);
+
+/** An amount (¥1,000, 1,000円, $9,000) in the sentence: it sets what is paid, and when is another clause's. */
+export const statesAmount = (text: string, currencies: readonly LexiconEntry[]): boolean =>
+  currencies
+    .filter((entry) => entry.pattern !== "")
+    .some((entry) => {
+      const parts = text.split(entry.pattern);
+      return parts.slice(1).some((after, index) => {
+        const before = parts[index] ?? "";
+        return entry.position === "before" ? DIGIT.test(after.trimStart().charAt(0)) : DIGIT.test(before.trimEnd().slice(-AMOUNT_REACH));
+      });
+    });
+
+const isWordStart = (text: string, at: number): boolean => !LETTER.test(text.charAt(at - 1));
+
+/** The sentence with the words that are no limit blanked out, so that a limit's words inside them are not read. */
+const withoutNotLimits = (text: Text, notLimits: readonly string[]): Text => ({
+  start: text.start,
+  text: notLimits.filter((word) => word !== "").reduce((masked, word) => masked.replaceAll(word, " ".repeat(word.length)), text.text),
+});
+
+const FRAME = "…";
+
+/** A phrase in the sentence; a Latin one only as whole words (by the, not by their). */
+const phraseIn = (text: string, phrase: string): boolean => {
+  const lower = text.toLowerCase();
+  const wanted = phrase.toLowerCase().trim();
+  if (wanted === "") return false;
+  if (!LATIN.test(wanted)) return lower.includes(wanted);
+  return [...lower.matchAll(new RegExp(escapeRegExp(wanted), "gu"))].some(
+    (match) => !LETTER.test(lower.charAt(match.index - 1)) && !LETTER.test(lower.charAt(match.index + wanted.length)),
+  );
+};
+
+/** A limit in the sentence: a frame (within … days) or a phrase (by the, までに), outside the words that are no limit. */
+const statesLimit = (text: Text, words: DutyWords): boolean => {
+  const masked = withoutNotLimits(text, words.notLimits);
+  const frames = words.limits.filter((limit) => limit.includes(FRAME));
+  return statesConcrete(masked, frames) || words.limits.some((limit) => !limit.includes(FRAME) && phraseIn(masked.text, limit));
+};
+
+const limited = (text: Text, words: DutyWords): boolean => statesLimit(text, words) || vagueIn(text, words.vague).length > 0;
+
+/** For each sentence, the index after the last sentence on its line: the time of a duty often follows it (Fees are due within 30 days). */
+const lineEnds = (texts: readonly Text[]): number[] => {
+  const ends: number[] = [];
+  texts.reduceRight((after, _text, index) => {
+    const end = texts[index + 1]?.sameLine === true ? after : index + 1;
+    ends[index] = end;
+    return end;
+  }, texts.length);
+  return ends;
+};
+
+/**
+ * Each duty to act at a point in time whose sentence, and the rest of whose line, states no limit, holds no vague one, grants no right and states
+ * no amount, when more sentences of the document state a limit than hold such a duty: these duties are then the
+ * document's minority.
+ */
+export const untimedDuties = (texts: readonly Text[], words: DutyWords): UntimedDuty[] => {
+  const ends = lineEnds(texts);
+  const found = texts.flatMap((text, index) => {
+    const line = texts.slice(index, ends[index]);
+    if (line.some((later) => limited(later, words) || words.deferrals.some((deferral) => phraseIn(later.text, deferral)))) return [];
+    if (grantsRight(text, words.permissions) || statesAmount(text.text, words.currencies)) return [];
+    const act = actIn(text.text, words);
+    if (act === undefined || (LATIN.test(act.act) && !isWordStart(text.text, act.at))) return [];
+    return [{ offset: text.start + act.at, act: text.text.slice(act.at, act.at + act.act.length) }];
+  });
+  const limitedSentences = texts.filter((text) => statesLimit(text, words)).length;
+  return limitedSentences > found.length ? found : [];
+};
+
+const patternsOf = (doc: ProseDocument, lexicon: string): string[] => (doc.lexicons[lexicon] ?? []).map((entry) => entry.pattern);
+
+export const obligationWithoutDeadline: Detector = (doc): Finding[] =>
+  untimedDuties(
+    doc.sentences.map((sentence, index) => ({
+      start: sentence.span.start,
+      text: sentence.text,
+      sameLine: index > 0 && !doc.source.slice(doc.sentences[index - 1]?.span.end ?? 0, sentence.span.start).includes("\n"),
+    })),
+    {
+      acts: patternsOf(doc, "timed-duty"),
+      markers: patternsOf(doc, "duty-marker"),
+      negations: patternsOf(doc, "duty-negation"),
+      endings: patternsOf(doc, "duty-ending"),
+      limits: [...patternsOf(doc, "concrete-deadline"), ...patternsOf(doc, "stated-deadline")],
+      notLimits: patternsOf(doc, "stated-deadline-not"),
+      vague: patternsOf(doc, "vague-deadline"),
+      deferrals: patternsOf(doc, "duty-terms-elsewhere"),
+      permissions: doc.lexicons["deadline-permission"] ?? [],
+      currencies: doc.lexicons["currency-notation"] ?? [],
+    },
+  ).map((duty) => ({
+    rule: "obligation-without-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: quoteAt(doc.source, duty.offset),
+    values: { word: duty.act, offset: duty.offset },
+  }));