chaffjs 0.20.0 → 0.21.0

package/src/detectors/mark-shape.ts

@@ -0,0 +1,202 @@
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence } from "../plugin.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { minorityReport } from "../spacing-minority.ts";
+import { isWithinAny, quotedSpans } from "../quoted-span.ts";
+
+/** The letters a mark must touch to count as part of the document's text, by language. */
+const SCRIPT: Readonly<Record<string, RegExp>> = {
+  ja: /[\p{Script=Han}\p{Script=Hiragana}\p{Script=Katakana}ー々]/u,
+  en: /\p{Script=Latin}/u,
+};
+
+/** One way of writing a mark: its kind, which of the two ways it is (side), and how the other way writes it. */
+type Form = { readonly kind: string; readonly side: boolean; readonly other: string };
+
+/**
+ * The two ways of writing each kind of mark, from the lexicon: pattern is one way, instead_of the other, group the kind.
+ * Two patterns may share one instead_of (“ and ” both against "), so the other way of a shared mark is both patterns.
+ */
+export const formsOf = (lexicon: Lexicon): ReadonlyMap<string, Form> => {
+  const forms = new Map<string, Form>();
+  lexicon.forEach((entry) => {
+    const kind = entry.group ?? entry.pattern;
+    const shared = entry.instead_of ?? "";
+    forms.set(entry.pattern, { kind, side: true, other: shared });
+    const known = forms.get(shared);
+    forms.set(shared, { kind, side: false, other: `${known?.side === false ? known.other : ""}${entry.pattern}` });
+  });
+  return forms;
+};
+
+export type Mark = { readonly sentence: Sentence; readonly char: string; readonly form: Form; readonly offset: number; readonly spaced: boolean };
+
+/** Punctuation that may stand between a closing or opening mark and the word it belongs to ("draft." and “draft”.). */
+const BETWEEN = /[.,;:!?。、]/u;
+
+/** The letter beside a mark on one side (step -1 or 1), past one punctuation mark. */
+const besideLetter = (text: string, at: number, step: number, script: RegExp): boolean => {
+  const next = text.charAt(at + step);
+  return script.test(next) || (BETWEEN.test(next) && script.test(text.charAt(at + step * 2)));
+};
+
+const touchesScript = (text: string, at: number, script: RegExp): boolean => besideLetter(text, at, -1, script) || besideLetter(text, at, 1, script);
+
+/** The marks in a sentence that touch a letter of the document's script, outside 「」『』 quotations. spaced is the lexicon's pattern side. */
+export const marksIn = (sentence: Sentence, forms: ReadonlyMap<string, Form>, script: RegExp): Mark[] => {
+  const quoted = quotedSpans(sentence.text);
+  return sentence.text.split("").flatMap((char, at) => {
+    const form = forms.get(char);
+    if (form === undefined || !touchesScript(sentence.text, at, script)) return [];
+    if (isWithinAny(quoted, { start: at, end: at })) return [];
+    return [{ sentence, char, form, offset: sentence.span.start + at, spaced: form.side }];
+  });
+};
+
+/** Something written one of two ways (spaced is which), at a place in a sentence. */
+type Sided = { readonly sentence: Sentence; readonly offset: number; readonly spaced: boolean };
+
+const sidedFinding = (item: Sided, values: Finding["values"], variant?: string): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: item.sentence.text.trim(),
+  ...(variant === undefined ? {} : { variant }),
+  values: { ...values, offset: item.offset },
+});
+
+/** The less common way, one finding each, or one finding for a document written both ways (spacing-minority.ts). */
+const minorityFindings = <T extends Sided>(items: readonly T[], limit: number, valuesOf: (item: T) => Finding["values"]): Finding[] => {
+  const report = minorityReport(items, limit);
+  if (report === undefined) return [];
+  if (report.mode === "mixed") {
+    const { first, odd, spaced, touching } = report;
+    return [sidedFinding(first, { ...valuesOf(first), spaced, touching, count: odd, of: items.length, limit }, "mixed")];
+  }
+  return report.odd.map((item) => sidedFinding(item, { ...valuesOf(item), count: report.odd.length, of: items.length, limit }));
+};
+
+/** Sentences written in the document's own language; a quoted sentence in another language follows its own marks. */
+const ownSentences = (doc: ProseDocument): readonly Sentence[] => doc.sentences.filter((sentence) => sentence.embeddedLanguage === undefined);
+
+/**
+ * A mark written two ways in one document (（ and (, “ and "), the less common way reported. The two ways come from the
+ * lexicon; neither is called right. Only marks next to a letter of the document's script count, so a bracket in code-like
+ * text (f(x)) or an English aside in a Japanese document does not.
+ */
+export const markConsistency: Detector = (doc, options): Finding[] => {
+  const script = SCRIPT[doc.language];
+  if (script === undefined) return [];
+  const forms = formsOf(options.lexicon ?? []);
+  const marks = ownSentences(doc).flatMap((sentence) => marksIn(sentence, forms, script));
+  const kinds = [...new Set(marks.map((mark) => mark.form.kind))];
+  return kinds.flatMap((kind) =>
+    minorityFindings(
+      marks.filter((mark) => mark.form.kind === kind),
+      options.limit,
+      (mark) => ({ mark: mark.char, usual: mark.form.other }),
+    ),
+  );
+};
+
+/**
+ * A sentence that surely ends: a lower-case word of two letters or more, then the mark. A number ("11.1."), an abbreviation
+ * ("Req.", "e.g.") or a capital ("U.S.") may be a split the adapter made inside a sentence, where one space is usual.
+ */
+const SENTENCE_END = /(?<![\p{L}\d.])\p{Ll}{2,}[.!?]["'”’)\]]?$/u;
+/** The next sentence starts with a capital, past an opening quote: not a citation ("[ISO99]") or an aside in brackets. */
+const SENTENCE_START = /^["'“‘]?\p{Lu}/u;
+const ONE_SPACE = " ";
+const TWO_SPACES = "  ";
+
+/** The space between two sentences on one line, when the first ends with a period, question or exclamation mark. spaced is two spaces. */
+export const sentenceGaps = (doc: ProseDocument): Sided[] =>
+  ownSentences(doc).flatMap((sentence, at, sentences) => {
+    const next = sentences[at + 1];
+    if (next === undefined || !SENTENCE_END.test(sentence.text) || !SENTENCE_START.test(next.text)) return [];
+    const gap = doc.source.slice(sentence.span.end, next.span.start);
+    if (gap !== ONE_SPACE && gap !== TWO_SPACES) return [];
+    return [{ sentence: next, spaced: gap === TWO_SPACES, offset: sentence.span.end }];
+  });
+
+/** One space between sentences and two, mixed in one document: the less common is reported. */
+export const sentenceSpacing: Detector = (doc, options): Finding[] =>
+  minorityFindings(sentenceGaps(doc), options.limit, (gap) => ({
+    spaces: gap.spaced ? TWO_SPACES.length : ONE_SPACE.length,
+    usual: gap.spaced ? ONE_SPACE.length : TWO_SPACES.length,
+  }));
+
+type Hit = { readonly sentence: Sentence; readonly matched: string; readonly offset: number };
+
+const hitFinding = (hit: Hit, count: number, limit: number): Finding => ({
+  rule: "",
+  severity: "info",
+  line: 0,
+  column: 0,
+  quote: hit.sentence.text.trim(),
+  values: { matched: hit.matched, count, limit, offset: hit.offset },
+});
+
+const hitsOf = (sentences: readonly Sentence[], pattern: RegExp): Hit[] =>
+  sentences.flatMap((sentence) =>
+    [...sentence.text.matchAll(pattern)].map((match) => ({ sentence, matched: match[0].trim(), offset: sentence.span.start + match.index })),
+  );
+
+const reportFrom = (hits: readonly Hit[], limit: number): Finding[] => (hits.length < limit ? [] : hits.map((hit) => hitFinding(hit, hits.length, limit)));
+
+/** 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);
+
+/** 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[] => {
+  const dots = [...abbreviation].flatMap((char, at) => (char === "." ? [at] : []));
+  const subsets = Array.from({ length: 2 ** dots.length }, (_unused, mask) => dots.filter((_dot, bit) => (mask >> bit) % 2 === 1));
+  return subsets
+    .filter((dropped) => dropped.length > 0 && dropped.length < dots.length)
+    .map((dropped) => [...abbreviation].filter((_char, at) => !dropped.includes(at)).join(""));
+};
+
+/** One partial form as a pattern: its first letter in either case, not inside a word, not followed by a period or letter. */
+const partialPattern = (form: string): string =>
+  `(?<![\\p{L}.])[${form.charAt(0).toLowerCase()}${form.charAt(0).toUpperCase()}]${escapeRegExp(form.slice(1))}(?![\\p{L}.])`;
+
+/** Latin abbreviations from the lexicon (e.g., i.e.) written with only some of their periods (e.g, eg.). */
+export const latinAbbreviation: Detector = (doc, options): Finding[] => {
+  const forms = (options.lexicon ?? []).flatMap((entry) => partialForms(entry.pattern));
+  if (forms.length === 0) return [];
+  const pattern = new RegExp(forms.map(partialPattern).join("|"), "gu");
+  return reportFrom(hitsOf(ownSentences(doc), pattern), options.limit);
+};
+
+/** How many all-capital words in a row read as shouting rather than a run of acronyms. */
+const SHOUT_WORDS = 3;
+const CAPS_RUN = new RegExp(`\\b[A-Z][A-Z']*(?:,? [A-Z][A-Z']*){${String(SHOUT_WORDS - 1)},}\\b`, "gu");
+/** One-letter words (I, A) may sit in a run, but a run of them alone ("A B C") is a list of labels. */
+const MIN_LONG_WORDS = 2;
+
+const LATIN_WORD = /[A-Za-z][A-Za-z']*/gu;
+
+/** The words a source writes at least once not wholly in capitals (do, Do), in lower case: words, not acronyms. */
+export const lowerCaseWords = (source: string): ReadonlySet<string> =>
+  new Set((source.match(LATIN_WORD) ?? []).filter((word) => word !== word.toUpperCase()).map((word) => word.toLowerCase()));
+
+/**
+ * Whether more than half the words of a capital run are also written elsewhere in lower case. Words the lexicon lists as
+ * written in capitals by convention (MUST NOT in a specification) count like acronyms.
+ */
+export const isShouting = (run: string, known: ReadonlySet<string>, conventional: ReadonlySet<string>): boolean => {
+  const words = run.split(/,? /u);
+  const ordinary = words.filter((word) => !conventional.has(word) && known.has(word.toLowerCase()));
+  const long = words.filter((word) => word.length > 1);
+  return long.length >= MIN_LONG_WORDS && ordinary.length * 2 > words.length;
+};
+
+/** Runs of three or more all-capital words that are ordinary words, not acronyms ("DO NOT DELETE THIS"). */
+export const capsShouting: Detector = (doc, options): Finding[] => {
+  const known = lowerCaseWords(doc.prose ?? doc.source);
+  const conventional = new Set((options.lexicon ?? []).map((entry) => entry.pattern));
+  const hits = hitsOf(ownSentences(doc), CAPS_RUN).filter((hit) => isShouting(hit.matched, known, conventional));
+  return reportFrom(hits, options.limit);
+};

package/src/detectors/registry/adverb-polarity.ts

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

package/src/detectors/registry/attachment-missing.ts

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

package/src/detectors/registry/bare-url-mix.ts

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

package/src/detectors/registry/caps-shouting.ts

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

package/src/detectors/registry/code-fence-language.ts

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

package/src/detectors/registry/defined-name-repeated.ts

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

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

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

package/src/detectors/registry/email-frame.ts

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

package/src/detectors/registry/email-subject.ts

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

package/src/detectors/registry/ending-run.ts

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

package/src/detectors/registry/heading-command.ts

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

package/src/detectors/registry/hyphen-dash.ts

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

package/src/detectors/registry/image-file-name-alt.ts

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

package/src/detectors/registry/impossible-date.ts

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

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

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

package/src/detectors/registry/latin-abbreviation.ts

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

package/src/detectors/registry/link-text-url-mismatch.ts

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

package/src/detectors/registry/mark-consistency.ts

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

package/src/detectors/registry/origin-particle.ts

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

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

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

package/src/detectors/registry/sentence-spacing.ts

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

package/src/detectors/registry/shell-prompt.ts

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

package/src/detectors/registry/step-statement.ts

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

package/src/detectors/registry/unpaired-parallel.ts

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

package/src/detectors/request-owner.ts

@@ -0,0 +1,141 @@
+// A request for an action (「資料をご確認ください」 "Please send the report.") with no deadline and no person or role,
+// in its own sentence or the next. The words come from the language's lexicons; the code only combines them.
+import type { Detector, Finding, Lexicon, ProseDocument, Sentence, Span, StructureNode } from "../plugin.ts";
+import { proseText } from "../measure.ts";
+import { comparableWords } from "./lexicon-match.ts";
+import { escapeRegExp } from "../orthography.ts";
+import { inDocumentOrder } from "../structure/issues.ts";
+
+/** The lexicons the rule reads, by name. A language without them checks nothing. */
+export const REQUEST_LEXICONS = {
+  ending: "request-ending",
+  action: "request-action",
+  condition: "request-condition",
+  deadline: "request-deadline",
+  owner: "request-owner",
+  pointer: "request-pointer",
+} as const;
+
+type Words = Readonly<Record<keyof typeof REQUEST_LEXICONS, readonly string[]>>;
+
+/** A clock time (14:00, 14時, 2pm) says when as much as a date does; a duration (3時間) does not. */
+const CLOCK = /\d{1,2}\s*(?:[:：]\d{2}|時(?!間)|\s?[ap]\.?m\.?(?![a-z]))/iu;
+
+const patternsOf = (lexicon: Lexicon | undefined): string[] => (lexicon ?? []).map((entry) => comparableWords(entry.pattern));
+
+const wordsOf = (doc: ProseDocument): Words => ({
+  ending: patternsOf(doc.lexicons[REQUEST_LEXICONS.ending]),
+  action: patternsOf(doc.lexicons[REQUEST_LEXICONS.action]),
+  condition: patternsOf(doc.lexicons[REQUEST_LEXICONS.condition]),
+  deadline: patternsOf(doc.lexicons[REQUEST_LEXICONS.deadline]),
+  owner: patternsOf(doc.lexicons[REQUEST_LEXICONS.owner]),
+  pointer: patternsOf(doc.lexicons[REQUEST_LEXICONS.pointer]),
+});
+
+/** How far apart, in characters, the action word and the request ending may be: the action must be what is requested. */
+const ACTION_REACH = 12;
+
+/** A Latin word matches whole words only ("by" is not in "maybe"); other scripts have no spaces to bound a word. */
+const matcherOf = (pattern: string): RegExp =>
+  /^[\p{Script=Latin}\d]/u.test(pattern)
+    ? new RegExp(`(?<![\\p{L}\\d])${escapeRegExp(pattern)}(?![\\p{L}\\d])`, "gu")
+    : new RegExp(escapeRegExp(pattern), "gu");
+
+type Place = { readonly start: number; readonly end: number };
+
+/** Where the lexicon's words occur in the text (after the comparable form: lower case, straight apostrophes). */
+const placesOf = (text: string, patterns: readonly string[]): Place[] => {
+  const comparable = comparableWords(text);
+  return patterns
+    .filter((pattern) => pattern !== "")
+    .flatMap((pattern) => [...comparable.matchAll(matcherOf(pattern))].map((match) => ({ start: match.index, end: match.index + match[0].length })));
+};
+
+export const containsAny = (text: string, patterns: readonly string[]): boolean => placesOf(text, patterns).length > 0;
+
+const gapBetween = (left: Place, right: Place): number => Math.max(left.start - right.end, right.start - left.end, 0);
+
+/**
+ * A request for an action: an action word next to a request ending (「確認してください」「please send」), not a condition
+ * (「ご不明な点があれば…ください」 is an offer), and not a pointer to where to read more (「詳細は資料をご確認ください」).
+ * The action has to be close to the ending, or a noun like 検討会 or 履修登録 earlier in the sentence would make one.
+ */
+export const isRequest = (text: string, words: Words): boolean => {
+  const endings = placesOf(text, words.ending);
+  const asked = placesOf(text, words.action).some((action) => endings.some((ending) => gapBetween(action, ending) <= ACTION_REACH));
+  return asked && !containsAny(text, words.condition) && !containsAny(text, words.pointer);
+};
+
+const NAMED = new Set(["PROPN"]);
+
+/** A proper noun in the request itself (「Ito, please share」) names who; one in the next sentence may be a product or a place. */
+const namesSomeone = (sentence: Sentence): boolean => (sentence.tokens ?? []).some((token) => NAMED.has(token.pos));
+
+const datedWithin = (dates: readonly Span[], span: Span): boolean => dates.some((date) => date.start >= span.start && date.start < span.end);
+
+type Bounds = { readonly starts: ReadonlySet<number>; readonly ends: ReadonlySet<number> };
+
+/** Where the sentence's words start and end in its comparable text, found by walking the token surfaces in order. */
+const wordBounds = (comparable: string, sentence: Sentence): Bounds | undefined => {
+  const tokens = sentence.tokens;
+  if (tokens === undefined || tokens.length === 0) return undefined;
+  const starts = new Set<number>();
+  const ends = new Set<number>();
+  tokens.reduce((from, token) => {
+    const surface = comparableWords(token.surface);
+    const at = surface === "" ? -1 : comparable.indexOf(surface, from);
+    if (at === -1) return from;
+    starts.add(at);
+    ends.add(at + surface.length);
+    return at + surface.length;
+  }, 0);
+  return { starts, ends };
+};
+
+/**
+ * Whether the sentence holds one of the words as whole words. With parts of speech a word must start and end on a word
+ * boundary, so 様 is not found in 同様, さん in たくさん, or まで in いままで; without them, as text.
+ */
+const holdsWord = (sentence: Sentence, patterns: readonly string[]): boolean => {
+  const comparable = comparableWords(proseText(sentence));
+  const bounds = wordBounds(comparable, sentence);
+  return placesOf(comparable, patterns).some((place) => bounds === undefined || (bounds.starts.has(place.start) && bounds.ends.has(place.end)));
+};
+
+/** Whether a sentence says when (a date, a clock time, a deadline word) or who (a role; a name in the request itself). */
+const saysWhenOrWho = (sentence: Sentence, words: Words, dates: readonly Span[], isRequestItself: boolean): boolean =>
+  datedWithin(dates, sentence.span) ||
+  CLOCK.test(proseText(sentence)) ||
+  holdsWord(sentence, words.deadline) ||
+  holdsWord(sentence, words.owner) ||
+  (isRequestItself && namesSomeone(sentence));
+
+/** A paragraph break or a new list item between two sentences: the second does not continue the first. */
+const BREAK = /\n[^\S\n]*\n|\n[^\S\n]*(?:[-*+]|\d+[.)])[^\S\n]/u;
+
+const continues = (source: string, sentence: Sentence, next: Sentence | undefined): next is Sentence =>
+  next !== undefined && !BREAK.test(source.slice(sentence.span.end, next.span.start));
+
+const dateSpans = (tree: StructureNode | undefined): Span[] =>
+  tree === undefined ? [] : inDocumentOrder(tree).flatMap((node) => (node.kind === "date" ? [node.span] : []));
+
+/** The request sentences with neither a deadline nor a person in them or in the sentence after, in the same paragraph or item. */
+export const ownerlessRequests = (doc: ProseDocument): Sentence[] => {
+  const words = wordsOf(doc);
+  const dates = dateSpans(doc.structure);
+  return doc.sentences.filter((sentence, index) => {
+    if (!isRequest(proseText(sentence), words) || saysWhenOrWho(sentence, words, dates, true)) return false;
+    const next = doc.sentences[index + 1];
+    return !continues(doc.source, sentence, next) || !saysWhenOrWho(next, words, dates, false);
+  });
+};
+
+export const requestWithoutDeadline: Detector = (doc: ProseDocument): Finding[] =>
+  ownerlessRequests(doc).map((sentence) => ({
+    rule: "request-without-deadline",
+    severity: "info",
+    line: 0,
+    column: 0,
+    quote: proseText(sentence),
+    values: { offset: sentence.span.start },
+  }));