chaffjs 0.31.0 → 0.33.0

package/src/product-names.ts

@@ -0,0 +1,98 @@
+import { escapeRegExp } from "./orthography.ts";
+
+// 製品の名前を、文書の中で二通りに書いた所（ミナモール錠 と ミナモル錠）。製品の名前は、製品の形を言う語（錠、カプセル、クリーム）の
+// すぐ前の、カタカナの連なり。形の語は語彙表 product-form が言い、group が同じ語は同じ形の別の書き方。作った製品の名前は解析器が
+// 固有名詞と読まず、読みも名前の字のとおりにずれるので、人や会社の名前の見方では比べられない。
+
+export type ProductForm = { readonly pattern: string; readonly group: string };
+
+/** surface は形の語も含めた書いたまま。base はカタカナの名前の部分、form は形の語の組。 */
+export type ProductMention = { readonly surface: string; readonly offset: number; readonly base: string; readonly form: string };
+
+export type ProductVariant = { readonly mention: ProductMention; readonly usual: string; readonly kind: "near" };
+
+const KATAKANA = /[\p{Script=Katakana}ー]/u;
+/** 形の語の後ろに続くと、長い語の一部になる字（錠剤、液晶、ゲルマニウム、スプレー缶）。 */
+const WORD_CONTINUES = /[\p{Script=Han}\p{Script=Katakana}ー]/u;
+/** 名前の部分の字の数の下限。短いカタカナ（ケア、ハーブ）は製品の名前でなく、ふつうの語のことが多い。 */
+const MIN_NAME_CHARS = 4;
+/** 名前を探す、形の語の前の範囲（UTF-16 の単位）。 */
+const LOOKBACK = 30;
+const LONG_VOWEL = "ー";
+
+/** at のすぐ前の、カタカナの連なり。 */
+const katakanaBefore = (source: string, at: number): string => {
+  const chars = Array.from(source.slice(Math.max(0, at - LOOKBACK), at));
+  return chars.slice(chars.findLastIndex((char) => !KATAKANA.test(char)) + 1).join("");
+};
+
+const mentionAt = (source: string, form: ProductForm, at: number): ProductMention | undefined => {
+  const end = at + form.pattern.length;
+  if (WORD_CONTINUES.test(source.charAt(end))) return undefined;
+  const base = katakanaBefore(source, at);
+  if (Array.from(base).length < MIN_NAME_CHARS) return undefined;
+  return { surface: source.slice(at - base.length, end), offset: at - base.length, base, form: form.group };
+};
+
+/** 文書の中の製品の名前の現れ。同じ所で終わる形の語は長いほうを取る（顆粒 と 粒）。 */
+export const productMentionsIn = (source: string, forms: readonly ProductForm[]): ProductMention[] => {
+  const ends = new Set<number>();
+  return forms
+    .toSorted((left, right) => right.pattern.length - left.pattern.length)
+    .flatMap((form) =>
+      [...source.matchAll(new RegExp(escapeRegExp(form.pattern), "gu"))].flatMap((match) => {
+        const end = match.index + form.pattern.length;
+        if (ends.has(end)) return [];
+        const mention = mentionAt(source, form, match.index);
+        if (mention !== undefined) ends.add(end);
+        return mention === undefined ? [] : [mention];
+      }),
+    )
+    .toSorted((left, right) => left.offset - right.offset);
+};
+
+/** 同じ長さで、一字だけ違う（ミナモール と ミナモオル）。 */
+const isOneReplaced = (left: readonly string[], right: readonly string[]): boolean =>
+  left.length === right.length && left.filter((char, index) => char !== right[index]).length === 1;
+
+/** longer から長音の記号を一つ抜くと shorter になる（ミナモール と ミナモル）。 */
+const dropsOneLongVowel = (longer: readonly string[], shorter: readonly string[]): boolean =>
+  longer.length === shorter.length + 1 && longer.some((char, index) => char === LONG_VOWEL && longer.toSpliced(index, 1).join("") === shorter.join(""));
+
+/** 二つのカタカナの名前が、一字の置き換えか、長音の記号一つの有る無しだけ違う。 */
+export const isKanaSlip = (left: string, right: string): boolean => {
+  const [leftChars, rightChars] = [Array.from(left), Array.from(right)];
+  return isOneReplaced(leftChars, rightChars) || dropsOneLongVowel(leftChars, rightChars) || dropsOneLongVowel(rightChars, leftChars);
+};
+
+type Counted = { readonly mention: ProductMention; readonly count: number };
+
+/**
+ * slip が usual の書き損じと言えるか。形の語の組が同じで、名前の部分が一字違いか長音の有る無しで、slip が一度だけ、usual が二度以上。
+ * 一字違いの別の製品もあるので、何度も書いた名前と一度だけの名前の組に限る。
+ */
+export const isProductSlip = (slip: Counted, usual: Counted): boolean =>
+  slip.count === 1 && usual.count >= 2 && slip.mention.form === usual.mention.form && isKanaSlip(slip.mention.base, usual.mention.base);
+
+/** 名前と形の語の組ごとに数える。同じ組の別の書き方（錠 と 錠剤）は同じ製品の現れ。 */
+const talliesOf = (mentions: readonly ProductMention[]): Counted[] => {
+  const tallies = new Map<string, Counted>();
+  mentions.forEach((mention) => {
+    const key = `${mention.base}\u0000${mention.form}`;
+    const tally = tallies.get(key);
+    tallies.set(key, { mention: tally?.mention ?? mention, count: (tally?.count ?? 0) + 1 });
+  });
+  return [...tallies.values()];
+};
+
+/** 多いほうが先。同数なら先に書いたほう。 */
+const byUsage = (left: Counted, right: Counted): number => right.count - left.count || left.mention.offset - right.mention.offset;
+
+/** 製品の名前の、一度だけ書いた書き損じ。相手のうち一番多いものと比べる。 */
+export const productVariants = (mentions: readonly ProductMention[]): ProductVariant[] => {
+  const tallies = talliesOf(mentions);
+  return tallies.flatMap((tally): ProductVariant[] => {
+    const [usual] = tallies.filter((other) => isProductSlip(tally, other)).toSorted(byUsage);
+    return usual === undefined ? [] : [{ mention: tally.mention, usual: usual.mention.surface, kind: "near" }];
+  });
+};

package/src/profile/parse.ts

@@ -61,6 +61,12 @@ const walkRateOf = (value: unknown): DocumentProfile["walkRate"] => {
   return { metresPerMinute, roundUp: value["round_up"] === true };
 };
 
+const WHOLE_PERCENT = 100;
+
+/** 0 より大きく 100 未満の数でなければ読まない。 */
+const taxRateOf = (value: unknown): number | undefined =>
+  typeof value === "number" && Number.isFinite(value) && value > 0 && value < WHOLE_PERCENT ? value : undefined;
+
 /** 単位が一つも無ければ読まない。何を指すのか決められない。 */
 const relativeOf = (value: unknown): RelativeVocabulary | undefined => {
   if (!isRecord(value)) return undefined;
@@ -97,6 +103,7 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
         const relative = relativeOf(section["relative"]);
         const unnumbered = unnumberedOf(section["unnumbered"]);
         const walkRate = walkRateOf(section["walk_rate"]);
+        const taxRate = taxRateOf(section["tax_rate"]);
         return [
           language,
           {
@@ -109,6 +116,7 @@ const languagesOf = (id: string, raw: Record<string, unknown>): Record<string, D
             unnumbered,
             ...(section["quote_mentions_term"] === true ? { quoteMentionsTerm: true } : {}),
             ...(walkRate === undefined ? {} : { walkRate }),
+            ...(taxRate === undefined ? {} : { taxRate }),
           },
         ];
       }),

package/src/reference-numbers.ts

@@ -0,0 +1,55 @@
+// A document's own reference number (a booking or confirmation number) written two ways: the same letters and digits with
+// two neighbours swapped (MN-48215 and MN-48251), both right after a label of the same kind. Pure: reads the document's text;
+// the labels (予約番号, Booking number) come from the language's reference-label lexicon, grouped by what they label.
+import type { LexiconEntry } from "./plugin.ts";
+import { labelBefore, swappedVariants, withoutUrls } from "./phone-numbers.ts";
+
+/** A reference number as written, where it is, its letters and digits without separators, and its label's group. */
+export type ReferenceNumber = { readonly offset: number; readonly written: string; readonly characters: string; readonly label: string };
+
+/** A reference number that is another of the same label with two neighbours swapped, and that other number. */
+export type ReferenceVariant = { readonly number: ReferenceNumber; readonly other: ReferenceNumber };
+
+/** Letters and digits, half or full width, joined by hyphens (MN-48215, AR730514, ＭＮ－４８２１５). */
+export const REFERENCE_SHAPE = /(?<![A-Za-z0-9Ａ-Ｚａ-ｚ０-９\-‐−－])[A-Za-z0-9Ａ-Ｚａ-ｚ０-９]+(?:[-‐−－][A-Za-z0-9Ａ-Ｚａ-ｚ０-９]+)*/gu;
+/** Digits enough that a swap is a slip in one number, not two short codes (A-12, B-21). */
+export const MIN_DIGITS = 4;
+export const MAX_CHARACTERS = 24;
+const DIGIT = /\d/gu;
+const SEPARATOR = /[-‐−－]/gu;
+/** Only spaces and a colon, comma or opening bracket between the label and its number (「予約番号：」, "booking number, "); not a sentence's end. */
+const LABEL_TO_NUMBER = /^[\s:：,，、#＃(（「『[［]{0,4}$/u;
+
+export const charactersOf = (written: string): string => written.normalize("NFKC").replaceAll(SEPARATOR, "").replaceAll(" ", "").toUpperCase();
+
+/** A first group a number in groups may open with: capitals and digits only (HM, 5520), not a word (No, Member). */
+const OPENING_GROUP = /^[0-9A-Z０-９Ａ-Ｚ]+$/u;
+/** One space, then four or more capitals and digits holding a digit, not run on into a word (8137 の; not 100 copies, 080, 2名, 2nd). */
+const FOLLOWING_GROUP = /^ (?=[0-9A-Z０-９Ａ-Ｚ]*[0-9０-９])[0-9A-Z０-９Ａ-Ｚ]{4,}(?![\p{L}\p{N}\-‐−－](?<!\p{Script=Hiragana}))/u;
+
+/** The groups after a number's first, written one space apart on its line (HM 5520 8137); none when the first is not a group. Reading stops once past the longest number, so a run-on is still too long. */
+export const followingGroups = (text: string, end: number, first: string): string => {
+  if (!OPENING_GROUP.test(first)) return "";
+  const read = (at: number, sofar: string): string => {
+    const tooLong = charactersOf(first + sofar).length > MAX_CHARACTERS;
+    const group = tooLong ? undefined : FOLLOWING_GROUP.exec(text.slice(at, at + MAX_CHARACTERS + 1))?.[0];
+    return group === undefined ? sofar : read(at + group.length, sofar + group);
+  };
+  return read(end, "");
+};
+
+/** The reference numbers of a text written right after a label on their line; unlabelled codes and URLs are not read. */
+export const labelledReferenceNumbers = (source: string, labels: readonly LexiconEntry[]): ReferenceNumber[] => {
+  const text = withoutUrls(source);
+  return [...text.matchAll(REFERENCE_SHAPE)].flatMap((match) => {
+    const written = match[0] + followingGroups(text, match.index + match[0].length, match[0]);
+    const characters = charactersOf(written);
+    if ((characters.match(DIGIT)?.length ?? 0) < MIN_DIGITS || characters.length > MAX_CHARACTERS) return [];
+    const label = labelBefore(text, match.index, labels);
+    if (label === undefined || !LABEL_TO_NUMBER.test(label.between)) return [];
+    return [{ offset: match.index, written, characters, label: label.group }];
+  });
+};
+
+/** Every writing of a reference number that is another of the same label with two neighbours swapped (swappedVariants). */
+export const referenceVariants = (numbers: readonly ReferenceNumber[]): ReferenceVariant[] => swappedVariants(numbers, (number) => number.characters);

package/src/run.ts

@@ -307,6 +307,7 @@ export const runRulesWith = (doc: ProseDocument, rules: readonly RuleDefinition[
       embeddedLimits: embeddedLimitsFor(rule, level, genre, embedded),
       ...(rule.options === undefined ? {} : { settings: optionValues(settleOptions(rule.id, rule.options, optionLayers)) }),
       ...(rule.custom === undefined ? {} : { custom: rule.custom }),
+      genre,
     };
     const ran = runDetector(detector, doc, options);
     if ("notRun" in ran) return { findings: acc.findings, skipped: [...acc.skipped, { rule: rule.id, why: ran.notRun }] };

package/src/spaced-person-name.ts

@@ -0,0 +1,97 @@
+import type { Span } from "./plugin.ts";
+import { isInPersonField as isFieldValue } from "./person-field.ts";
+
+// 空白を挟んで書いた姓と名（高瀬 誠、佐伯 未咲）を、解析器の品詞に頼らず、前後の語で人の名前と読む。解析器は姓を地名やふつうの
+// 名詞と読み、名を二語に切ることがあるので、姓と名を一つの名前にできない。後ろに敬称か肩書き（様、部長）が付くか、人を書く欄
+// （氏名：、承認者：）の行の終わりにあれば、人の名前と読む。欄に書いた名と同じ名を空白の後ろに書いたもの（受託者：西村 亮 の
+// 文書の 西邑 亮が）も、人の名前と読む。
+
+/** suffixes は敬称（様、さん）、titles は名前のすぐ後ろの肩書き（部長）、labels は人を書く欄の語（氏名、承認者）。語彙表から。 */
+export type SpacedNameCues = { readonly suffixes: readonly string[]; readonly titles: readonly string[]; readonly labels: readonly string[] };
+
+export type SpacedName = { readonly surname: Span; readonly given: Span };
+
+/** 姓と名それぞれの字数の上限。長い漢字の連なり（営業部長）は姓でない。 */
+const MAX_PART = 3;
+/** 姓の前を読む範囲（UTF-16 の単位）。姓より長い漢字の連なりを、長いまま見るため。 */
+const LOOKBACK = 12;
+const NAME_SPACE = /[\u0020\u3000]/gu;
+const HAN = /^\p{Script=Han}$/u;
+const LEADING_HAN = /^\p{Script=Han}+/u;
+/** 文字列の頭と終わりの一字（𠮷 は UTF-16 の二つで一字）。 */
+const FIRST_LETTER = /^./u;
+const LAST_LETTER = /.$/u;
+const ONE_SPACE = /^[\u0020\u3000]/u;
+/** 欄の語と名前のあいだに置かない記号。文の中の「：」の後ろは欄ではない。 */
+const NOT_IN_FIELD = /[。、，,：:]/u;
+const FIELD_COLON = /[：:]/u;
+/** 欄の行の頭の、Markdown の印（箇条書き、引用、見出し）。 */
+const LINE_MARKS = /^[\s>*#+-]*/u;
+/** 欄の名前の後ろ: 行の終わり。日付などの括弧一つで行が終わってもよい（髙瀬 誠（2026年4月1日））。 */
+const FIELD_END = /^[\u0020\u3000]*(?:[（(][^（()）\n]*[）)][\u0020\u3000]*)?(?:\r?\n|$)/u;
+
+const isHan = (letter: string | undefined): boolean => letter !== undefined && HAN.test(letter);
+
+/** 人を書く欄の行（承認者：営業部長 高瀬 誠）で、姓が欄の語の後ろにあるか。 */
+const isInPersonField = (source: string, surnameStart: number, labels: readonly string[]): boolean => {
+  const head = source.slice(source.lastIndexOf("\n", surnameStart - 1) + 1, surnameStart);
+  const colon = head.search(FIELD_COLON);
+  if (colon < 0 || NOT_IN_FIELD.test(head.slice(colon + 1))) return false;
+  const label = head.slice(0, colon).replace(LINE_MARKS, "").trimEnd();
+  return labels.some((word) => label.endsWith(word));
+};
+
+/** 空白の後ろの漢字の連なりの頭から、敬称か肩書きの前までを名と読む（誠部長 の 誠、健太 様 の 健太）。 */
+const givenBeforeSuffix = (run: string, after: string, words: readonly string[]): string | undefined => {
+  const letters = [...run];
+  return letters
+    .slice(0, MAX_PART)
+    .map((_letter, index) => letters.slice(0, index + 1).join(""))
+    .find((given) => {
+      const rest = given.length === run.length ? after.replace(ONE_SPACE, "") : run.slice(given.length) + after;
+      return words.some((word) => rest.startsWith(word));
+    });
+};
+
+/** fieldGivens は、文書が人を書く欄に書いた名（亮）。その名と同じ漢字の連なりは、敬称が無くても名と読む。 */
+const givenAt = (source: string, start: number, cues: SpacedNameCues, inField: boolean, fieldGivens: ReadonlySet<string>): string | undefined => {
+  const run = LEADING_HAN.exec(source.slice(start, start + LOOKBACK))?.[0];
+  if (run === undefined) return undefined;
+  const after = source.slice(start + run.length, start + run.length + LOOKBACK);
+  const suffixed = givenBeforeSuffix(run, after, [...cues.suffixes, ...cues.titles]);
+  if (suffixed !== undefined) return suffixed;
+  if (fieldGivens.has(run)) return run;
+  return inField && [...run].length <= MAX_PART && FIELD_END.test(after) ? run : undefined;
+};
+
+/** 空白の前の漢字の連なり。字数が姓の形で、肩書きや敬称で終わらない（部長 高瀬様 の 部長 は姓でない）。 */
+const surnameBefore = (source: string, space: number, cues: SpacedNameCues): string | undefined => {
+  const window = source.slice(Math.max(0, space - LOOKBACK), space);
+  const letters = [...window];
+  const run = letters.slice(letters.findLastIndex((letter) => !isHan(letter)) + 1).join("");
+  if (run === "" || [...run].length > MAX_PART) return undefined;
+  return [...cues.titles, ...cues.suffixes].some((word) => run.endsWith(word)) ? undefined : run;
+};
+
+const namesIn = (source: string, cues: SpacedNameCues, fieldGivens: ReadonlySet<string>): SpacedName[] =>
+  [...source.matchAll(NAME_SPACE)].flatMap((match) => {
+    const space = match.index;
+    if (!isHan(LAST_LETTER.exec(source.slice(Math.max(0, space - 2), space))?.[0]) || !isHan(FIRST_LETTER.exec(source.slice(space + 1, space + 3))?.[0]))
+      return [];
+    const surname = surnameBefore(source, space, cues);
+    if (surname === undefined) return [];
+    const surnameStart = space - surname.length;
+    const given = givenAt(source, space + 1, cues, isInPersonField(source, surnameStart, cues.labels), fieldGivens);
+    return given === undefined ? [] : [{ surname: { start: surnameStart, end: space }, given: { start: space + 1, end: space + 1 + given.length } }];
+  });
+
+/**
+ * 空白を挟んだ姓と名で、後ろに敬称か肩書きが付くか、人を書く欄の行の終わりにあるもの。欄に書いた名と同じ名を書いたもの
+ * （受託者：西村 亮 と 西邑 亮が）も。
+ */
+export const spacedPersonNamesIn = (source: string, cues: SpacedNameCues): SpacedName[] => {
+  const fields = namesIn(source, cues, new Set()).filter(({ surname, given }) =>
+    isFieldValue(source, surname.start, given.end - surname.start, cues.labels, cues.suffixes),
+  );
+  return namesIn(source, cues, new Set(fields.map(({ given }) => source.slice(given.start, given.end))));
+};

package/src/spacing-code.ts

@@ -1,7 +1,9 @@
 import type { Span } from "./plugin.ts";
+import { HYPHEN_CHARS } from "./orthography.ts";
 
 // Text beside which a space is not a spacing choice: a clock time (13:30), which like 3時 names a time rather than a
-// quantity, and an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it. Pure.
+// quantity, an e-mail address or a URL, whose end a reader and an auto-linker find by the space after it, and an
+// identifier such as a booking or model number (MN-48215, SB-210), which a space sets off from the sentence. Pure.
 
 /** A clock time: hours, a colon, minutes, and seconds optionally (9:05, 13:30, 08:00:15). */
 const CLOCK_TIME = /(?<![\d:：.])\d{1,2}[:：][0-5]\d(?:[:：][0-5]\d)?(?![\d:：])/gu;
@@ -15,6 +17,20 @@ const URL_START = /^(?:https?:\/\/|www\.)/u;
 
 const isAddress = (word: string): boolean => EMAIL.test(word) || URL_START.test(word);
 
+/**
+ * An identifier: letters and digits joined by hyphens with three digits or more in a row (MN-48215, SB-210, KM-SP300), or
+ * capitals followed by four digits or more (A1234567). A shorter name with a digit (EC2, H30, UTF-8, COVID-19) is a word
+ * the writer spaces like any other.
+ */
+// The hyphen may be full-width or Japanese (KM－SP300), as in the hyphenated numbers orthography.ts reads.
+const HYPHENATED = new RegExp(
+  `(?<![A-Za-z0-9.${HYPHEN_CHARS}])[A-Za-z0-9]+(?:[${HYPHEN_CHARS}][A-Za-z0-9]+)+(?![A-Za-z0-9${HYPHEN_CHARS}]|\\.[A-Za-z0-9])`,
+  "gu",
+);
+const CAPITALS_SERIAL = new RegExp(`(?<![A-Za-z0-9.${HYPHEN_CHARS}])[A-Z]+\\d{4,}(?![A-Za-z0-9${HYPHEN_CHARS}]|\\.[A-Za-z0-9])`, "gu");
+const HAS_LETTER = /[A-Za-z]/u;
+const SERIAL_DIGITS = /\d{3}/u;
+
 const spansOf = (text: string, pattern: RegExp): Span[] =>
   [...text.matchAll(pattern)].map((match) => ({ start: match.index, end: match.index + match[0].length }));
 
@@ -22,5 +38,10 @@ export const clockTimeSpans = (text: string): Span[] => spansOf(text, CLOCK_TIME
 
 export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).filter((span) => isAddress(text.slice(span.start, span.end)));
 
+const isIdentifier = (word: string): boolean => HAS_LETTER.test(word) && SERIAL_DIGITS.test(word);
+
+export const identifierSpans = (text: string): Span[] =>
+  [...spansOf(text, HYPHENATED), ...spansOf(text, CAPITALS_SERIAL)].filter((span) => isIdentifier(text.slice(span.start, span.end)));
+
 /** Whether the character at `at` is inside one of the spans. */
 export const isInsideSpan = (spans: readonly Span[], at: number): boolean => spans.some((span) => span.start <= at && at < span.end);

package/src/structure/annual-holidays.ts

@@ -0,0 +1,222 @@
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/**
+ * annual-holidays-mismatch: a job posting's annual days off (年間休日 90日) fewer than its weekly days off give over a year
+ * (完全週休2日制 is two days off every week, at least 104 a year). Only a lower bound: public holidays, summer and the
+ * new year add to it. A weekly phrase that is not every week (週休2日制 is two days off in at least one week a month), a
+ * negated one, one with an exception beside it, an approximate or open count, two different counts and two weekly phrases
+ * with different minimums leave the posting unchecked. The words come from the lexicons. Pure.
+ */
+
+export type PositionedWord = { readonly word: string; readonly position: "before" | "after" };
+
+/** A weekly phrase and the fewest days off a year it gives; undefined for a phrase that is not every week (週休2日制). */
+export type WeeklyWord = { readonly word: string; readonly minimum: number | undefined };
+
+export type AnnualHolidaysWords = {
+  /** Labels of the annual days off: before the count (年間休日 125日) or after it, with the word of a day in it (125 days off a year). */
+  readonly labels: readonly PositionedWord[];
+  /** The word of a day after a count (日, days). */
+  readonly days: readonly string[];
+  /** Words that may stand between a label and its count (は, is). */
+  readonly links: readonly string[];
+  readonly weekly: readonly WeeklyWord[];
+  /** Words that negate a weekly phrase: right after it (ではない) or earlier in its sentence (not). */
+  readonly negations: readonly PositionedWord[];
+  /** Words after a weekly phrase on its line that make an exception to it (除く, 出勤, except). */
+  readonly exceptions: readonly string[];
+  /** Words that make a count approximate or open (約, 以上, about, at least). */
+  readonly markers: readonly PositionedWord[];
+  /** Marks and words that join the two ends of a range (〜, to). */
+  readonly connectors: readonly string[];
+};
+
+type Span = { readonly start: number; readonly end: number };
+type DayCount = Span & { readonly days: number; readonly clear: boolean };
+type Weekly = Span & { readonly minimum: number | undefined; readonly clear: boolean };
+
+/** How far from a count a marker (約, 以上) or the start of a range is looked for. */
+const MARKER_REACH = 12;
+const LATIN = /[A-Za-z]/u;
+const SEPARATORS = /[\s|｜:：=＝、，,・/／()（）[\]［］-]/gu;
+const PARENTHETICAL_WITHOUT_DIGITS = /[（(][^()（）0-9０-９]*[)）]/gu;
+const SENTENCE_END = /[。！？；;]|[.!?](?=\s|$)/u;
+const SENTENCE_SPLIT = /[。！？；;]|[.!?](?=\s)/u;
+const RANGE_START = /[0-9０-９]\s*$/u;
+const COUNT = "(?<![0-9０-９.,，．])([0-9０-９]+)";
+
+const DIGIT = /[0-9０-９]/u;
+
+/** The edge a word needs on one side: a Latin word stands apart from letters, a number from digits (4-day is not in 14-day). */
+const edgeOf = (char: string): string => {
+  if (LATIN.test(char)) return "[A-Za-z]";
+  return DIGIT.test(char) ? "[0-9０-９]" : "";
+};
+
+const wordPattern = (word: string): string => {
+  const start = edgeOf(word.charAt(0));
+  const end = edgeOf(word.charAt(word.length - 1));
+  return [start === "" ? "" : `(?<!${start})`, escapeRegExp(word), end === "" ? "" : `(?!${end})`].join("");
+};
+
+/** One alternation of the words, longest first so 完全週休2日制 wins over 週休2日制. Undefined when there are none. */
+const alternation = (words: readonly string[]): string | undefined =>
+  words.length === 0
+    ? undefined
+    : words
+        .toSorted((left, right) => right.length - left.length)
+        .map(wordPattern)
+        .join("|");
+
+const occurrences = (text: string, words: readonly string[]): Span[] => {
+  const pattern = alternation(words);
+  if (pattern === undefined) return [];
+  return [...text.matchAll(new RegExp(pattern, "giu"))].map((match) => ({ start: match.index, end: match.index + match[0].length }));
+};
+
+const contains = (text: string, words: readonly string[]): boolean => occurrences(text, words).length > 0;
+
+const wordsAt = (words: readonly PositionedWord[], position: "before" | "after"): string[] =>
+  words.filter((word) => word.position === position).map((word) => word.word.toLowerCase());
+
+const lineEnd = (text: string, offset: number): number => {
+  const end = text.indexOf("\n", offset);
+  return end === -1 ? text.length : end;
+};
+
+const lineStart = (text: string, offset: number): number => text.lastIndexOf("\n", offset - 1) + 1;
+
+/** Where a statement that starts at offset ends: at the end of its sentence or line. */
+const statementEnd = (text: string, offset: number): number => {
+  const end = lineEnd(text, offset);
+  const sentence = SENTENCE_END.exec(text.slice(offset, end));
+  return sentence === null ? end : offset + sentence.index;
+};
+
+/** The sentence before offset, from its start: where a negation of a phrase is looked for (does not have …). */
+const sentenceBefore = (text: string, offset: number): string => text.slice(lineStart(text, offset), offset).split(SENTENCE_SPLIT).at(-1) ?? "";
+
+/** Whether only separators, bracketed words without digits and the given words stand in the gap (「：」, " is "). */
+export const isPlainGap = (gap: string, words: readonly string[]): boolean => {
+  const pattern = alternation(words);
+  const bare = gap.replace(PARENTHETICAL_WITHOUT_DIGITS, "");
+  return (pattern === undefined ? bare : bare.replace(new RegExp(pattern, "giu"), "")).replace(SEPARATORS, "") === "";
+};
+
+/** Whether text starts with the word, a Latin word ending there ("to" is not the start of "total"). */
+const startsWithWord = (text: string, word: string): boolean =>
+  text.startsWith(word) && !(LATIN.test(word.charAt(word.length - 1)) && LATIN.test(text.charAt(word.length)));
+
+/** Whether text ends with the word, a Latin word starting there ("over" is not the end of "moreover"). */
+const endsWithWord = (text: string, word: string): boolean =>
+  text.endsWith(word) && !(LATIN.test(word.charAt(0)) && LATIN.test(text.charAt(text.length - word.length - 1)));
+
+/** Whether a count is approximate (約90日, 90日以上), open (90日〜) or the end of a range (80〜90日). */
+const isMarked = (text: string, span: Span, words: AnnualHolidaysWords): boolean => {
+  const before = text
+    .slice(Math.max(0, span.start - MARKER_REACH), span.start)
+    .trimEnd()
+    .toLowerCase();
+  const after = text
+    .slice(span.end, span.end + MARKER_REACH)
+    .trimStart()
+    .toLowerCase();
+  const connectors = words.connectors.map((connector) => connector.toLowerCase());
+  const ranged = connectors.some((connector) => endsWithWord(before, connector) && RANGE_START.test(before.slice(0, -connector.length)));
+  const markedBefore = wordsAt(words.markers, "before").some((marker) => endsWithWord(before, marker));
+  const markedAfter = [...wordsAt(words.markers, "after"), ...connectors].some((marker) => startsWithWord(after, marker));
+  return ranged || markedBefore || markedAfter;
+};
+
+const countOf = (written: string): number => Number(written.normalize("NFKC"));
+
+const gapWords = (words: AnnualHolidaysWords): string[] => [...words.links, ...wordsAt(words.markers, "before")];
+
+/** The gap without the start of a range at its end (年間休日 100〜|120日), so the range is read and found not plain. */
+const withoutRangeStart = (gap: string, days: string, words: AnnualHolidaysWords): string => {
+  const connectors = alternation(words.connectors);
+  return connectors === undefined ? gap : gap.replace(new RegExp(`[0-9０-９]+\\s*(?:${days})?\\s*(?:${connectors})\\s*$`, "iu"), "");
+};
+
+/**
+ * The count a label before it states (年間休日：125日): the first count of days in its statement, joined to it by a plain
+ * gap. A marker (年間休日は約120日) or a range's start in the gap is read, so the count is found not plain rather than missed.
+ */
+const countAfterLabel = (text: string, label: Span, words: AnnualHolidaysWords): DayCount | undefined => {
+  const days = alternation(words.days);
+  if (days === undefined) return undefined;
+  const end = statementEnd(text, label.end);
+  const match = new RegExp(`${COUNT}\\s*(?:${days})`, "iu").exec(text.slice(label.end, end));
+  if (match === null || !isPlainGap(withoutRangeStart(text.slice(label.end, label.end + match.index), days, words), gapWords(words))) return undefined;
+  const span = { start: label.end + match.index, end: label.end + match.index + match[0].length };
+  return { ...span, days: countOf(match[1] ?? ""), clear: !isMarked(text, span, words) };
+};
+
+/** The counts a label after them states (125 days off a year). */
+const countsBeforeLabels = (text: string, words: AnnualHolidaysWords): DayCount[] => {
+  const labels = alternation(wordsAt(words.labels, "after"));
+  if (labels === undefined) return [];
+  return [...text.matchAll(new RegExp(`${COUNT}\\s*(?:${labels})`, "giu"))].map((match) => {
+    const span = { start: match.index, end: match.index + match[0].length };
+    return { ...span, days: countOf(match[1] ?? ""), clear: !isMarked(text, span, words) };
+  });
+};
+
+/** Every annual count of days off the document states, in document order. */
+export const annualCountsIn = (text: string, words: AnnualHolidaysWords): DayCount[] => {
+  const after = occurrences(text, wordsAt(words.labels, "before")).flatMap((label) => countAfterLabel(text, label, words) ?? []);
+  return [...after, ...countsBeforeLabels(text, words)].toSorted((left, right) => left.start - right.start);
+};
+
+/** Whether a weekly phrase is negated (完全週休2日制ではない, does not offer two days off every week). */
+const isNegated = (text: string, span: Span, words: AnnualHolidaysWords): boolean => {
+  const after = text
+    .slice(span.end, span.end + MARKER_REACH)
+    .trimStart()
+    .toLowerCase();
+  return (
+    wordsAt(words.negations, "after").some((word) => startsWithWord(after, word)) ||
+    contains(sentenceBefore(text, span.start), wordsAt(words.negations, "before"))
+  );
+};
+
+/** Every weekly phrase in the document, each with the fewest days off a year it gives and whether it can be read plainly. */
+export const weeklyIn = (text: string, words: AnnualHolidaysWords): Weekly[] => {
+  const minimums = new Map(words.weekly.map((entry): [string, number | undefined] => [entry.word.toLowerCase(), entry.minimum]));
+  return occurrences(
+    text,
+    words.weekly.map((entry) => entry.word),
+  ).map((span) => {
+    const minimum = minimums.get(text.slice(span.start, span.end).toLowerCase());
+    const excepted = contains(text.slice(span.end, lineEnd(text, span.end)), words.exceptions);
+    return { ...span, minimum, clear: minimum !== undefined && !excepted && !isNegated(text, span, words) };
+  });
+};
+
+/**
+ * The weekly phrase whose minimum all the document's weekly phrases agree on; undefined when there is none, one is not
+ * plain, or two give different minimums (完全週休2日制 for one role and 完全週休3日制 for another).
+ */
+const agreedWeekly = (weekly: readonly Weekly[]): Weekly | undefined => {
+  const [first] = weekly;
+  if (first === undefined) return undefined;
+  return weekly.every((entry) => entry.clear && entry.minimum === first.minimum) ? first : undefined;
+};
+
+/** The one count all the document's counts agree on; undefined when there is none, one is not plain, or two differ. */
+const agreedCount = (counts: readonly DayCount[]): DayCount | undefined => {
+  const [first] = counts;
+  if (first === undefined) return undefined;
+  return counts.every((count) => count.clear && count.days === first.days) ? first : undefined;
+};
+
+/** Every annual count of days off below the fewest the posting's weekly days off give. */
+export const annualHolidaysMismatches = (text: string, words: AnnualHolidaysWords): StructureIssue[] => {
+  const counts = annualCountsIn(text, words);
+  const count = agreedCount(counts);
+  const weekly = agreedWeekly(weeklyIn(text, words));
+  if (count === undefined || weekly?.minimum === undefined || count.days >= weekly.minimum) return [];
+  const values = { days: count.days, weekly: text.slice(weekly.start, weekly.end), minimum: weekly.minimum };
+  return counts.map((each) => ({ offset: each.start, values: { ...values, written: text.slice(each.start, each.end) } }));
+};