chaffjs 0.28.0 → 0.30.0

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,176 @@
 import type { Detector, Finding, ProseDocument } from "../plugin.ts";
-import { mentionsIn, nameVariants, suffixedNamesIn, type VariantChars } from "../name-variants.ts";
+import { cuedNamesIn, mentionsIn, nameVariants, suffixedNamesIn, withKnownNeighbours, 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 { proseAndTablesOf } from "../table-text.ts";
+import { tableBodyCells } from "../facts/table-facts.ts";
+import { cellNamesIn, cellNameVariants, proseNamesOf } from "../table-names.ts";
+import { placeMentionsIn, placeVariants, type PlaceReader, type PlaceWord } from "../place-names.ts";
+import type { TableCell, Token } from "../plugin.ts";
+import { proseWithCells } from "../table-cells.ts";
+import { labelledSpans, orderNamesOf, quotedSpans, stemOf, titleCaseSpans, wordOrderVariants, type OrderWord } from "../name-word-order.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"]);
+
+/** 表の本体の升。本文が表を覆わない文書（Markdown でない）には無い。 */
+const cellsOf = (doc: ProseDocument): readonly TableCell[] => doc.tableCells?.() ?? tableBodyCells(proseAndTablesOf(doc));
+
+/** 文の語と表の升の語を、文書の順に。 */
+const tokensOf = (doc: ProseDocument): Token[] =>
+  [...doc.sentences.flatMap((sentence) => sentence.tokens ?? []), ...cellsOf(doc).flatMap((cell) => cell.tokens ?? [])].toSorted(
+    (left, right) => left.span.start - right.span.start,
+  );
+
+/** 場所の名前の語の数の上限。名前の読みを探す範囲。 */
+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(proseWithCells(prose, cellsOf(doc)), 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 }));
+
+/** 名前の中で比べる語の品詞。助詞や冠詞（の、of）は語の順に数えない。 */
+const CONTENT_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN", "ADJ", "NUM", "VERB"]);
+
+/** 欄の後ろの名前を切る所: 内容語でも名前の中の小さな語（of）でもない語の頭。 */
+const orderStopsOf = (doc: ProseDocument): number[] => {
+  const joiners = new Set(patternsOf(doc, "name-title-joiner"));
+  return tokensOf(doc)
+    .filter((token) => !CONTENT_POS.has(token.pos) && !joiners.has(token.surface.toLowerCase()))
+    .map((token) => token.span.start);
+};
+
+const sentenceStartsOf = (doc: ProseDocument): ReadonlySet<number> => new Set(doc.sentences.flatMap((sentence) => sentence.tokens?.[0]?.span.start ?? []));
+
+const orderWordsOf = (doc: ProseDocument): OrderWord[] => {
+  const suffixes = patternsOf(doc, "name-stem-suffix");
+  return tokensOf(doc)
+    .filter((token) => CONTENT_POS.has(token.pos))
+    .map((token) => ({ start: token.span.start, end: token.span.end, key: stemOf(token.surface, suffixes) }));
+};
+
+/**
+ * 語の順を入れ替えて書いた同じ名前（統計学基礎 と 基礎統計学）。名前と読める所は、括弧の中（name-quote）、大文字で始まる語の並び
+ * （name-title-joiner を挟んでよい）、名前を書く欄の後ろ（name-label）。大文字の語の並びどうしは、片方が表の升まるごとに
+ * 書いた名前のときだけ比べる。ほかの見方がすでに指した所と重なるものは除く。
+ */
+const orderFindings = (doc: ProseDocument, prose: string, reported: readonly Reported[]): Reported[] => {
+  const starts = sentenceStartsOf(doc);
+  const spans = [
+    ...quotedSpans(prose, patternsOf(doc, "name-quote")),
+    ...titleCaseSpans(prose, patternsOf(doc, "name-title-joiner"), (offset) => starts.has(offset)),
+    ...labelledSpans(prose, patternsOf(doc, "name-label")),
+  ];
+  const cells = new Set(tableBodyCells(proseAndTablesOf(doc)).map((cell) => cell.text.trim()));
+  return wordOrderVariants(orderNamesOf(doc.source, spans, orderWordsOf(doc), orderStopsOf(doc)), cells)
+    .filter(({ name }) => !overlapsAny(reported, name.offset, name.surface.length))
+    .map(({ name, usual }) => ({ offset: name.offset, name: name.surface, usual, kind: "order" }));
+};
+
+/** 人・製品・会社の名前の現れ。解析器が固有名詞と読む語、敬称の付く名前、前後の語で名前と読める漢字。 */
+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)];
+  const cued = [...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 };
+  });
+  return withKnownNeighbours(cued, prose).toSorted((left, right) => left.offset - right.offset);
+};
+
+/** 表の升に書いた名前の書き分け。名前の形をした升を、本文の名前と比べる。ほかの見方がすでに指した所と重なるものは除く。 */
+const tableFindings = (doc: ProseDocument, prose: string, mentions: readonly NameMention[], reported: readonly Reported[]): Reported[] =>
+  cellNameVariants(cellNamesIn(cellsOf(doc)), proseNamesOf(mentions, prose))
+    .filter(({ name }) => !reported.some((other) => other.offset < name.offset + name.surface.length && name.offset < other.offset + other.name.length))
+    .map(({ name, usual, kind }) => ({ offset: name.offset, name: name.surface, usual, kind }));
+
 /** 同じ名前を、文書の中で少しだけ違う形に書いた所（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 mentions = nameMentionsOf(doc, prose, chars);
+  const names = nameVariants(mentions, chars).map(({ mention, usual, kind }): Reported => ({
+    offset: mention.offset,
+    name: mention.surface,
+    usual,
+    kind,
   }));
+  const namesAndCompanies = [...names, ...companyFindings(doc, prose, names)];
+  const withTables = [...namesAndCompanies, ...tableFindings(doc, prose, mentions, namesAndCompanies)];
+  const withPlaces = [...withTables, ...placeFindings(doc, prose, withTables)];
+  return [...withPlaces, ...orderFindings(doc, prose, withPlaces)]
+    .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 },
+  }));