chaffjs 0.28.0 → 0.30.0

package/src/structure/ordinal-runs.ts

@@ -0,0 +1,107 @@
+// The numbered runs a schedule writes as 第N回, 第N週, Week N or Session N (lexicon ordinal-frame), in the first cell of
+// table rows, at the start of list items or at the start of lines, and the places where such a run skips or repeats a
+// number. Pure: the frames come from the lexicon, the leads from the caller.
+import type { Lexicon } from "../plugin.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** One frame of the lexicon: the form with its number, and the form's opening followed by a figure. */
+export type OrdinalFrame = { readonly group: string; readonly written: RegExp; readonly opened: RegExp | undefined };
+
+/** A lead that carries a frame: its number (or the first and last of a joined 1-2) as written. */
+export type FramedNumber = { readonly group: string; readonly ordinal: number; readonly last: number; readonly label: string };
+
+/** A lead that opens a frame (第2, Week 3) without the form being readable (第2・第3回): it ends the group's run. */
+export type UnreadableFrame = { readonly group: string; readonly unreadable: true };
+
+/** Where a lead starts and what it reads as. */
+export type Lead = { readonly offset: number; readonly read: readonly (FramedNumber | UnreadableFrame)[] };
+
+const PLACEHOLDER = "{n}";
+const FIGURES = "[0-9０-９]{1,3}";
+const JOINER = "[ \\t]?[-–—~〜～・,、][ \\t]?";
+const FOLLOWER = "(?=$|[\\s\\u3000:：|（(.)）\\]\\-–—、,*_])";
+const SPACE = /[ \t\u3000]+/gu;
+const FULLWIDTH_ZERO = 0xff10;
+
+const escaped = (text: string): string => text.replace(/[.*+?^${}()|[\]\\]/gu, "\\$&").replace(SPACE, "[ \\t\\u3000]*");
+
+const frameOf = (pattern: string, group: string): OrdinalFrame | undefined => {
+  const at = pattern.indexOf(PLACEHOLDER);
+  if (at === -1) return undefined;
+  const opening = escaped(pattern.slice(0, at));
+  const closing = escaped(pattern.slice(at + PLACEHOLDER.length));
+  const written = new RegExp(`^${opening}(?<first>${FIGURES})(?:${JOINER}(?<last>${FIGURES}))?${closing}${FOLLOWER}`, "iu");
+  return { group, written, opened: opening === "" ? undefined : new RegExp(`^${opening}[0-9０-９]`, "iu") };
+};
+
+/** The lexicon's frames. An entry without {n} or without a group is not a frame. */
+export const ordinalFramesOf = (lexicon: Lexicon): OrdinalFrame[] =>
+  lexicon.flatMap((entry) => {
+    const frame = entry.group === undefined ? undefined : frameOf(entry.pattern, entry.group);
+    return frame === undefined ? [] : [frame];
+  });
+
+const figureValue = (figures: string): number =>
+  Number([...figures].map((char) => (char >= "０" && char <= "９" ? String(char.charCodeAt(0) - FULLWIDTH_ZERO) : char)).join(""));
+
+const readFrame = (lead: string, frame: OrdinalFrame): FramedNumber | UnreadableFrame | undefined => {
+  const found = frame.written.exec(lead);
+  if (found === null) return frame.opened?.test(lead) === true ? { group: frame.group, unreadable: true } : undefined;
+  const ordinal = figureValue(found.groups?.["first"] ?? "");
+  const last = found.groups?.["last"];
+  return { group: frame.group, ordinal, last: last === undefined ? ordinal : figureValue(last), label: found[0].trim() };
+};
+
+/** What the text at the start of a lead reads as, under each frame that matches it. */
+export const framesAt = (lead: string, frames: readonly OrdinalFrame[]): Lead["read"] => {
+  const read = frames.flatMap((frame) => readFrame(lead, frame) ?? []);
+  const groups = new Set(read.filter((each) => !("unreadable" in each)).map((each) => each.group));
+  return read.filter((each) => !("unreadable" in each) || !groups.has(each.group));
+};
+
+/** One number of a run, and where its lead starts. */
+export type RunNumber = FramedNumber & { readonly offset: number };
+
+/**
+ * The leads of one block (one table, one list, one section's lines), cut into runs per group. An unreadable lead ends its
+ * group's run, and a number 1 starts a new one (a second term counting again).
+ */
+export const ordinalRuns = (leads: readonly Lead[]): RunNumber[][] => {
+  const runs: RunNumber[][] = [];
+  const open = new Map<string, RunNumber[]>();
+  leads.forEach((lead) =>
+    lead.read.forEach((read) => {
+      if ("unreadable" in read) {
+        open.delete(read.group);
+        return;
+      }
+      const openRun = open.get(read.group) ?? [];
+      const run = read.ordinal === 1 && openRun.length > 0 ? [] : openRun;
+      if (run.length === 0) runs.push(run);
+      open.set(read.group, run);
+      run.push({ ...read, offset: lead.offset });
+    }),
+  );
+  return runs;
+};
+
+/** A run shorter than this is too short to tell a numbering from a mention. */
+const SHORTEST_RUN = 3;
+
+const followsOn = (current: FramedNumber, previous: FramedNumber): boolean => current.ordinal === previous.last + 1;
+
+/**
+ * Each number in the run that does not follow the one before it: a skip or a repeat. A run
+ * where fewer than half the steps follow on lists chosen numbers (weeks 2, 5, 9), not a sequence, and is not read; so
+ * is a run shorter than three, and a run writing one number throughout.
+ */
+export const ordinalRunBreaks = (run: readonly RunNumber[]): StructureIssue[] => {
+  if (run.length < SHORTEST_RUN || new Set(run.map((item) => item.ordinal)).size < 2) return [];
+  const steps = run.slice(1).map((item, index) => ({ item, previous: run[index] ?? item }));
+  const breaks = steps.filter(({ item, previous }) => !followsOn(item, previous));
+  if (breaks.length * 2 > steps.length) return [];
+  return breaks.map(({ item, previous }) => ({
+    offset: item.offset,
+    values: { previous: previous.label, label: item.label, expected: previous.last + 1, found: item.ordinal },
+  }));
+};

package/src/structure/party-order.ts

@@ -0,0 +1,115 @@
+import type { BodyText } from "./definition-use.ts";
+
+/**
+ * 当事者の呼び名を並べた所（甲及び乙、甲又は乙、甲乙、甲、乙及び丙）と、文書がふだん書く順と逆に並べた所。
+ * 並べる語は言語パッケージの語彙表から取る。向きのある言い方（乙から甲へ、甲が乙に）は並べる語でつながないので読まない。
+ */
+export type ListingWords = {
+  /** 当事者の呼び名（甲、乙、文書が定めた委託者）。 */
+  readonly labels: readonly string[];
+  /** 間に語を置かずに並べてよい呼び名（甲乙）。 */
+  readonly bareLabels: readonly string[];
+  /** 並べる語（及び、又は、・）。 */
+  readonly joiners: readonly string[];
+  /** 同じ並びのあとに並べる語があるときだけつなぐ印（甲、乙及び丙の「、」）。 */
+  readonly seriesMarks: readonly string[];
+};
+
+export type PartyListing = { readonly start: number; readonly end: number; readonly labels: readonly string[] };
+
+export type OrderSlip = { readonly listing: PartyListing; readonly usual: PartyListing; readonly usualCount: number; readonly reverseCount: number };
+
+type Link = "joiner" | "series" | "bare";
+type Step = { readonly link: Link; readonly label: string; readonly end: number };
+
+/** 呼び名の前の一字がこれなら、呼び名は長い語の一部（乙種の前の語、1丁目）。 */
+const WORD_CHAR = /[\p{Script=Han}\p{Script=Katakana}\p{Script=Latin}\p{N}ー]/u;
+
+const longestAt = (text: string, at: number, words: readonly string[]): string | undefined =>
+  words
+    .filter((word) => word !== "" && text.startsWith(word, at))
+    .reduce<string | undefined>((best, word) => (best === undefined || word.length > best.length ? word : best), undefined);
+
+const stepAfter = (text: string, at: number, previous: string, words: ListingWords): Step | undefined => {
+  const linked = (link: Link, mark: string | undefined): Step | undefined => {
+    if (mark === undefined) return undefined;
+    const label = longestAt(text, at + mark.length, words.labels);
+    return label === undefined ? undefined : { link, label, end: at + mark.length + label.length };
+  };
+  const bare = words.bareLabels.includes(previous) ? longestAt(text, at, words.bareLabels) : undefined;
+  const side: Step | undefined = bare === undefined ? undefined : { link: "bare", label: bare, end: at + bare.length };
+  return linked("joiner", longestAt(text, at, words.joiners)) ?? linked("series", longestAt(text, at, words.seriesMarks)) ?? side;
+};
+
+/** 並べた語の数。「、」は、そのあとに並べる語が無ければ並びの終わり（「甲、乙は」は並べたと読まない）。 */
+const linksKept = (links: readonly Link[]): number => {
+  const lastJoiner = links.lastIndexOf("joiner");
+  const series = links.findIndex((link, index) => link === "series" && index > lastJoiner);
+  return series === -1 ? links.length : series;
+};
+
+/** 最後の呼び名が長い語の頭なら並びに入れない（乙及び甲種株式の甲）。間を置かずに並べた甲乙は、あとに語が続いてよい（甲乙間、甲乙双方）。 */
+const endsInWord = (text: string, steps: readonly Step[]): boolean => {
+  const last = steps.at(-1);
+  return last !== undefined && last.link !== "bare" && WORD_CHAR.test(text.charAt(last.end));
+};
+
+const listingAt = (text: BodyText, at: number, first: string, words: ListingWords): PartyListing => {
+  const steps: Step[] = [];
+  let end = at + first.length;
+  for (let step = stepAfter(text.text, end, first, words); step !== undefined; step = stepAfter(text.text, end, step.label, words)) {
+    steps.push(step);
+    end = step.end;
+  }
+  const whole = endsInWord(text.text, steps) ? steps.slice(0, -1) : steps;
+  const kept = whole.slice(0, linksKept(whole.map((step) => step.link)));
+  const last = kept.at(-1);
+  return { start: text.start + at, end: text.start + (last === undefined ? at + first.length : last.end), labels: [first, ...kept.map((step) => step.label)] };
+};
+
+/** 一つの文の中の並び。呼び名が二つ以上で、違う呼び名を並べたものだけ。 */
+const listingsIn = (text: BodyText, words: ListingWords): PartyListing[] => {
+  const found: PartyListing[] = [];
+  let at = 0;
+  while (at < text.text.length) {
+    const first = WORD_CHAR.test(text.text.charAt(at - 1)) ? undefined : longestAt(text.text, at, words.labels);
+    const listing = first === undefined ? undefined : listingAt(text, at, first, words);
+    if (listing !== undefined && new Set(listing.labels).size > 1) found.push(listing);
+    at = listing !== undefined && listing.labels.length > 1 ? listing.end - text.start : at + 1;
+  }
+  return found;
+};
+
+export const partyListings = (texts: readonly BodyText[], words: ListingWords): PartyListing[] => texts.flatMap((text) => listingsIn(text, words));
+
+const pairsOf = (labels: readonly string[]): [string, string][] =>
+  labels.flatMap((first, index) => labels.slice(index + 1).flatMap((second): [string, string][] => (second === first ? [] : [[first, second]])));
+
+const keyOf = (left: string, right: string): string => `${left}\u0000${right}`;
+
+const byPair = (listings: readonly PartyListing[]): Map<string, PartyListing[]> => {
+  const pairs = new Map<string, PartyListing[]>();
+  listings.forEach((listing) =>
+    new Set(pairsOf(listing.labels).map(([first, second]) => keyOf(first, second))).forEach((key) => pairs.set(key, [...(pairs.get(key) ?? []), listing])),
+  );
+  return pairs;
+};
+
+/**
+ * 文書がふだん書く順と逆に並べた所。ふだんの順は、同じ二つの呼び名を並べた所の多い方で、逆の順の minRatio 倍以上あるときだけ
+ * 決まる（同じ数なら、どちらとも言えないので指さない）。
+ */
+export const reversedListings = (listings: readonly PartyListing[], minRatio: number): OrderSlip[] => {
+  const pairs = byPair(listings);
+  return listings.flatMap((listing) => {
+    const slips = pairsOf(listing.labels).flatMap(([first, second]): OrderSlip[] => {
+      const reverse = pairs.get(keyOf(first, second)) ?? [];
+      const usual = pairs.get(keyOf(second, first)) ?? [];
+      const example = usual[0];
+      return example === undefined || usual.length < minRatio * reverse.length
+        ? []
+        : [{ listing, usual: example, usualCount: usual.length, reverseCount: reverse.length }];
+    });
+    return slips.slice(0, 1);
+  });
+};

package/src/structure/percent-sum-prose.ts

@@ -1,5 +1,6 @@
 // A breakdown written in one sentence (「構成比は、Aが50%、Bが30%、Cが20%」, "By product, A made up 50% of sales, B 30% and
 // C 20%") whose shares do not add up to 100%. The table and list form is structure/percent-sum.ts; the words are the same.
+import { escapeRegExp } from "../orthography.ts";
 import type { Span } from "../plugin.ts";
 import type { StructureIssue } from "./issues.ts";
 import type { Amount } from "./total.ts";
@@ -35,20 +36,62 @@ const toleranceOf = (source: string, shares: readonly Amount[]): number =>
 
 const isBroken = (sum: number, tolerance: number): boolean => Math.abs(sum - WHOLE) > tolerance && Math.abs(sum - WHOLE) <= BAND;
 
+/** How far before a percentage the word for the rest may stand: 「その他が 」, "and other ". */
+const REST_REACH = 16;
+/** What may stand between the word for the rest and its percentage: a space, a colon, a particle, an opening parenthesis. */
+const REST_GAP = /^[\s:：、,がはで(（]*$/u;
+const LATIN_START = /^[A-Za-z]/u;
+const LETTER_BEFORE = /\p{L}$/u;
+const LETTER = /\p{L}/u;
+
+/** A word in a text; a Latin one as a whole word ("other", not "another"; "up", not "upkeep"). */
+const hasWord = (text: string, word: string): boolean => {
+  const lowered = text.toLowerCase();
+  const target = word.toLowerCase();
+  if (!LATIN_START.test(word)) return lowered.includes(target);
+  return [...lowered.matchAll(new RegExp(escapeRegExp(target), "gu"))].some(
+    (match) => !LETTER.test(lowered[match.index - 1] ?? "") && !LETTER.test(lowered[match.index + target.length] ?? ""),
+  );
+};
+
+/** How far from a percentage a word for which way it moved may stand: "grew 45%", 「8%増加」. */
+const CHANGE_REACH = 12;
+
+const movesNear = (source: string, sentence: Span, share: Amount, changes: readonly string[]): boolean => {
+  const near = source.slice(Math.max(sentence.start, share.offset - CHANGE_REACH), Math.min(sentence.end, share.end + CHANGE_REACH));
+  return changes.some((word) => hasWord(near, word));
+};
+
+/**
+ * The last share is the rest of the whole (その他が 5%, other 5%): only the parts of one whole have a rest, and it is listed
+ * last. Percentages next to a word for which way they moved (grew 45%, 8%増加) are changes, whose rest is no part of a whole.
+ */
+const namesRest = (source: string, sentence: Span, shares: readonly Amount[], words: ShareWords): boolean => {
+  const last = shares.at(-1);
+  if (last === undefined || shares.some((share) => movesNear(source, sentence, share, words.changes ?? []))) return false;
+  const before = source.slice(Math.max(sentence.start, last.offset - REST_REACH), last.offset).toLowerCase();
+  return (words.rests ?? []).some((word) => {
+    const at = before.lastIndexOf(word.toLowerCase());
+    if (at < 0 || !REST_GAP.test(before.slice(at + word.length))) return false;
+    return !(LATIN_START.test(word) && LETTER_BEFORE.test(before.slice(0, at)));
+  });
+};
+
 const issueIn = (source: string, sentence: Span, percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
   const text = source.slice(sentence.start, sentence.end);
-  if (!includesAny(text, words.labels) || includesAny(text, words.exceptions)) return [];
+  if (includesAny(text, words.exceptions)) return [];
   const shares = percents.filter((amount) => amount.offset >= sentence.start && amount.end <= sentence.end);
   if (shares.length < MIN_PARTS || shares.some((share) => isSigned(source, share))) return [];
+  if (!includesAny(text, words.labels) && !namesRest(source, sentence, shares, words)) return [];
   const sum = shares.reduce((total, share) => total + share.value, 0);
   const decimals = Math.max(0, ...shares.map((share) => decimalsOf(source, share)));
   if (!isBroken(sum, toleranceOf(source, shares))) return [];
   return [{ offset: shares[0]?.offset ?? sentence.start, values: { sum: `${sum.toFixed(decimals)}${shares[0]?.unit ?? ""}` } }];
 };
 
-/** Each sentence that names a share word and three or more unsigned percentages whose sum misses 100% by more than rounding, and by no more than BAND. */
+/** Each sentence that names a share word (or names one share as the rest) and three or more unsigned percentages whose sum misses 100% by more than rounding, and by no more than BAND. */
 export const proseShareMismatches = (source: string, sentences: readonly Span[], amounts: readonly Amount[], words: ShareWords): StructureIssue[] => {
-  if (words.labels.length === 0) return [];
+  if (words.labels.length === 0 && (words.rests ?? []).length === 0) return [];
   const percents = amounts.filter((amount) => words.units.includes(amount.unit));
   return sentences.flatMap((sentence) => issueIn(source, sentence, percents, words));
 };

package/src/structure/percent-sum.ts

@@ -3,6 +3,7 @@ import { runsOf, TABLE_ROW, TABLE_RULE, type Line } from "./runs.ts";
 import { columnOf, isTotalLabel, type Amount } from "./total.ts";
 import { CELL_SEPARATOR } from "./bare-numbers.ts";
 import { joined, lineAbove, linesAbove } from "../text-above.ts";
+import { isShareColumn, mentionsAny } from "./share-column.ts";
 
 /**
  * 一つの全体を分けた割合（構成比、内訳、breakdown）の和が 100% にならない。箇条書きの続いた項目か、表の続いた行の百分率を足す。
@@ -11,8 +12,16 @@ import { joined, lineAbove, linesAbove } from "../text-above.ts";
  */
 export type ShareWords = {
   readonly labels: readonly string[];
+  /** 表の列の見出しの升がその語だけのとき、全体を分けた割合の列と読む語（割合、Weight）。 */
+  readonly columnLabels?: readonly string[];
+  /** 行ごとの率を名指す語（前年比、達成率、growth）。表の上の文にあれば、columnLabels の列は足さない。 */
+  readonly rates?: readonly string[];
   /** 足しても 100% にならない集計（複数回答）。 */
   readonly exceptions: readonly string[];
+  /** 全体の残りを名指す語（その他、other）。一つの文の百分率のすぐ前にあれば、その文は内訳。 */
+  readonly rests?: readonly string[];
+  /** 値の動いた向きの語（伸び、grew）。その文の百分率は変化で、「その他」があっても内訳ではない。 */
+  readonly changes?: readonly string[];
   readonly units: readonly string[];
   readonly totalLabels: readonly string[];
 };
@@ -97,12 +106,13 @@ const tolerance = (shares: readonly Share[]): number => Math.max(1, shares.lengt
 /** 和は、項目のいちばん細かい桁で、最初の項目の単位を付けて見せる。 */
 const shownSum = (shares: readonly Share[]): string => `${sumOf(shares).toFixed(decimalsOf(shares))}${shares[0]?.unit ?? ""}`;
 
-type Named = { readonly header: readonly string[]; readonly above: string };
+type Named = { readonly header: readonly string[]; readonly above: string; readonly rows: string };
 
 /** 列が全体を分けた割合と名指されているか。表は列の見出しか、百分率の列が一つだけの表の上の文。箇条書きは上の文。 */
 const namesShares = (named: Named, column: number, percentColumns: number, words: ShareWords): boolean => {
   const header = named.header[column] ?? "";
   if (named.header.length > 0 && includesAny(header, words.labels)) return true;
+  if (isShareColumn(header, words.columnLabels ?? []) && !mentionsAny(`${named.above} ${named.rows}`, words.rates ?? [])) return true;
   return (named.header.length === 0 || percentColumns === 1) && includesAny(named.above, words.labels);
 };
 
@@ -110,7 +120,11 @@ const namesShares = (named: Named, column: number, percentColumns: number, words
 const isBreakdown = (source: string, run: readonly Line[], totalLabels: readonly string[]): boolean =>
   run.length >= MIN_PARTS && !run.some((line) => isTotalLabel(source.slice(line.start, line.end), totalLabels));
 
-const namingOf = (source: string, run: readonly Line[], first: Line): Named => ({ header: headerCells(source, first), above: textAbove(source, run) });
+const namingOf = (source: string, run: readonly Line[], first: Line): Named => ({
+  header: headerCells(source, first),
+  above: textAbove(source, run),
+  rows: run.map((line) => source.slice(line.start, line.end)).join("\n"),
+});
 
 const mismatchesIn = (source: string, run: readonly Line[], percents: readonly Amount[], words: ShareWords): StructureIssue[] => {
   const first = run[0];

package/src/structure/release-list.ts

@@ -0,0 +1,69 @@
+// The releases a document lists: a run of version headings (## 3.2.0 - 2026-09-14), each with its section, or a run of
+// list items that start with a version (- 3.2.0 (2026-09-14): ...). Pure: reads the source, its headings and code fences.
+import type { Span } from "../plugin.ts";
+import type { Release } from "./install-pin.ts";
+import { runsOf, type Line } from "./runs.ts";
+import { isVersionHistory, leadingVersion } from "./version-order.ts";
+
+export type Heading = Span & { readonly depth: number; readonly text: string };
+
+const BARE = /\d[\w.-]*/u;
+
+/** The version as compared: 3.2.0 from [v3.2.0]. */
+const bareVersion = (label: string): string => BARE.exec(label)?.[0] ?? label;
+
+type Labelled = Release & { readonly label: string };
+
+/** Kept only when its versions read as a history (all versions, newest or oldest first), not as section numbers. */
+const asHistory = (run: readonly Labelled[]): Release[] =>
+  isVersionHistory(run.map((release) => release.label)) ? run.map(({ version, start, end }) => ({ version, start, end })) : [];
+
+/** A heading's section: up to the next heading of its depth or shallower. */
+const sectionEnd = (headings: readonly Heading[], index: number, length: number): number => {
+  const depth = headings[index]?.depth ?? 0;
+  return headings.slice(index + 1).find((later) => later.depth <= depth)?.start ?? length;
+};
+
+/**
+ * Version headings one after another at one depth. A deeper heading (### Added) stays inside the run; any other heading
+ * at its depth or shallower (## Install) ends it, so versioned headings spread over a manual are no release list.
+ */
+const headingReleases = (headings: readonly Heading[], length: number): Release[] => {
+  const runs: Labelled[][] = [];
+  const open: { depth: number; run: Labelled[] } = { depth: 0, run: [] };
+  headings.forEach((heading, index) => {
+    const label = leadingVersion(heading.text);
+    const continues = label !== undefined && heading.depth === open.depth;
+    if (!continues && (label !== undefined || heading.depth <= open.depth)) {
+      open.run = [];
+      open.depth = label === undefined ? 0 : heading.depth;
+      runs.push(open.run);
+    }
+    if (label !== undefined) open.run.push({ label, version: bareVersion(label), start: heading.start, end: sectionEnd(headings, index, length) });
+  });
+  return runs.flatMap(asHistory);
+};
+
+const ITEM_MARKER = /^[ \t]*(?:[-*+]|\d{1,3}[.)])[ \t]*/u;
+
+const itemReleases = (source: string, run: readonly Line[]): Release[] =>
+  asHistory(
+    run.flatMap((line) => {
+      const text = source.slice(line.start, line.end);
+      const marker = ITEM_MARKER.exec(text)?.[0];
+      const label = marker === undefined ? undefined : leadingVersion(text.slice(marker.length));
+      return label === undefined ? [] : [{ label, version: bareVersion(label), start: line.start, end: line.end }];
+    }),
+  );
+
+/** Every release the document lists, outside code fences (an example changelog in a block is not the document's). */
+export const releasesOf = (source: string, headings: readonly Heading[], fences: readonly Span[]): Release[] => {
+  const inFence = (line: Line): boolean => fences.some((fence) => line.start >= fence.start && line.start < fence.end);
+  const items = runsOf(source).flatMap((run) =>
+    itemReleases(
+      source,
+      run.filter((line) => line.kind === "list" && !inFence(line)),
+    ),
+  );
+  return [...headingReleases(headings, source.length), ...items].toSorted((left, right) => left.start - right.start);
+};

package/src/structure/requirement-lists.ts

@@ -0,0 +1,145 @@
+// required-listed-as-preferred: one skill or qualification listed under a required heading or label and again under a
+// preferred one. The headings and labels, the units and words of a length of experience, and the words that only end an
+// item come from the lexicons. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import type { StructureIssue } from "./issues.ts";
+
+/** A heading, a line standing alone (a label if it is one of the words), or one list item, in document order. */
+export type RequirementBlock =
+  | { readonly kind: "heading"; readonly depth: number; readonly text: string; readonly offset: number }
+  | { readonly kind: "line"; readonly text: string; readonly offset: number }
+  | { readonly kind: "item"; readonly text: string; readonly offset: number };
+
+export type ValuedWord = { readonly word: string; readonly value: number };
+
+export type RequirementWords = {
+  /** Headings and labels of what an applicant must have (必須, Required) and of what is welcome (歓迎, Preferred). */
+  readonly required: readonly string[];
+  readonly preferred: readonly string[];
+  /** Units of a length of experience, valued in months (年 12, month 1). */
+  readonly units: readonly ValuedWord[];
+  /** Words that stand before or after a length and belong to it (at least, 以上, of). */
+  readonly before: readonly string[];
+  readonly after: readonly string[];
+  /** Numbers written as words (three, 三). */
+  readonly numbers: readonly ValuedWord[];
+  /** Words that only end an item and are not the skill (の方, こと). */
+  readonly endings: readonly string[];
+};
+
+type Kind = "required" | "preferred";
+
+/** container is the offset of the heading holding the lists (a posting, 応募の条件), -1 for none; only one container's items are compared. */
+type Requirement = { readonly kind: Kind; readonly text: string; readonly offset: number; readonly container: number };
+
+/** The skill an item names with its length of experience taken out, and that length in months (0 when none). */
+type Reading = { readonly core: string; readonly months: number };
+
+const MARKS = /[*_`~]/gu;
+
+const LATIN = /^[a-z]/u;
+
+const plain = (text: string): string => text.normalize("NFKC").toLowerCase().replace(MARKS, "").replace(/\s+/gu, " ").trim();
+
+/** A Latin word is matched at word edges; other scripts as written. */
+const wordPattern = (word: string): string => {
+  const escaped = escapeRegExp(plain(word));
+  return LATIN.test(plain(word)) ? `(?<![a-z])${escaped}(?![a-z])` : escaped;
+};
+
+const alternation = (words: readonly string[]): string =>
+  words
+    .toSorted((left, right) => right.length - left.length)
+    .map(wordPattern)
+    .join("|");
+
+/** The text without the characters at either end that the test accepts (no backtracking regex on long lines). */
+const trimWhere = (text: string, isEdge: (char: string) => boolean): string => {
+  const chars = [...text];
+  const start = chars.findIndex((char) => !isEdge(char));
+  return start === -1 ? "" : chars.slice(start, chars.findLastIndex((char) => !isEdge(char)) + 1).join("");
+};
+
+const LABEL_EDGE = /[\s【［[「(（】］\]」)）:：]/u;
+
+const asLabel = (text: string): string => trimWhere(plain(text).replace(/[-‐–]/gu, " "), (char) => LABEL_EDGE.test(char)).replace(/\s+/gu, " ");
+
+const kindOfLabel = (label: string, words: RequirementWords): Kind | undefined => {
+  if (label === "") return undefined;
+  if (words.required.some((word) => asLabel(word) === label)) return "required";
+  return words.preferred.some((word) => asLabel(word) === label) ? "preferred" : undefined;
+};
+
+const HEADING_PARTS = /[・/／、,，(（:：]/u;
+
+/** A heading names its kind by its first part (必須スキル・経験, 歓迎（あれば尚可）); a line standing alone, by all of it. */
+const kindOfHeading = (text: string, words: RequirementWords): Kind | undefined => kindOfLabel(asLabel(text.split(HEADING_PARTS)[0] ?? ""), words);
+
+type Scope = { readonly depth: number; readonly kind: Kind | undefined; readonly offset: number };
+
+type Walk = { readonly scopes: readonly Scope[]; readonly label: Kind | undefined; readonly items: readonly Requirement[] };
+
+/** A heading opens a scope that its subheadings inherit unless they name their own kind; a label holds until the next heading or label. */
+const step = (walk: Walk, block: RequirementBlock, words: RequirementWords): Walk => {
+  if (block.kind === "heading") {
+    const outer = walk.scopes.filter((scope) => scope.depth < block.depth);
+    const kind = kindOfHeading(block.text, words) ?? outer.at(-1)?.kind;
+    return { ...walk, scopes: [...outer, { depth: block.depth, kind, offset: block.offset }], label: undefined };
+  }
+  if (block.kind === "line") {
+    const kind = kindOfLabel(asLabel(block.text), words);
+    return kind === undefined ? walk : { ...walk, label: kind };
+  }
+  const kind = walk.label ?? walk.scopes.at(-1)?.kind;
+  const container = walk.scopes.findLast((scope) => scope.kind === undefined)?.offset ?? -1;
+  return kind === undefined ? walk : { ...walk, items: [...walk.items, { kind, text: block.text.trim(), offset: block.offset, container }] };
+};
+
+const numberPattern = (words: RequirementWords): string =>
+  [String.raw`\d+(?:\.\d+)?`, alternation(words.numbers.map((entry) => entry.word))].filter((part) => part !== "").join("|");
+
+const lengthPattern = (words: RequirementWords): RegExp | undefined => {
+  if (words.units.length === 0) return undefined;
+  const before = words.before.length === 0 ? "" : `(?:(?:${alternation(words.before)})\\s*)?`;
+  const after = words.after.length === 0 ? "" : `(?:\\s*(?:${alternation(words.after)}))*`;
+  return new RegExp(`${before}(${numberPattern(words)})\\s*\\+?\\s*(${alternation(words.units.map((unit) => unit.word))})['’]?${after}`, "gu");
+};
+
+const valueOf = (written: string, words: readonly ValuedWord[]): number => words.find((entry) => plain(entry.word) === written)?.value ?? Number(written);
+
+/** Punctuation, symbols and spaces, but not the + and # that end a name (C++, C#). */
+const PUNCTUATION = /(?<![\p{L}\p{N}+#])[+#]|[^\p{L}\p{N}+#]/gu;
+
+const EDGE_PUNCTUATION = /[\p{P}\s]/u;
+
+const withoutEnding = (written: string, endings: readonly string[]): string => {
+  const text = trimWhere(written, (char) => char !== "#" && EDGE_PUNCTUATION.test(char));
+  const ending = endings.map(plain).find((word) => word !== "" && text.endsWith(word) && text.length > word.length);
+  return ending === undefined ? text : withoutEnding(text.slice(0, -ending.length), endings);
+};
+
+const readingOf = (text: string, words: RequirementWords): Reading => {
+  const written = plain(text);
+  const pattern = lengthPattern(words);
+  const lengths = pattern === undefined ? [] : [...written.matchAll(pattern)];
+  const months = lengths.map((match) => valueOf(match[1] ?? "", words.numbers) * (words.units.find((unit) => plain(unit.word) === match[2])?.value ?? 0));
+  const rest = pattern === undefined ? written : written.replace(pattern, " ");
+  return { core: withoutEnding(rest.replace(/\s+/gu, " ").trim(), words.endings).replace(PUNCTUATION, ""), months: Math.max(0, ...months) };
+};
+
+/** A preferred item repeats a required one when it names the same skill and asks for no longer experience. */
+const repeats = (preferred: Reading, required: Reading): boolean =>
+  preferred.core !== "" && preferred.core === required.core && preferred.months <= required.months;
+
+/** The preferred items that repeat a required item of the same document, once each, in document order. */
+export const requiredListedAsPreferred = (blocks: readonly RequirementBlock[], words: RequirementWords): StructureIssue[] => {
+  const { items } = blocks.reduce<Walk>((walk, block) => step(walk, block, words), { scopes: [], label: undefined, items: [] });
+  const required = items.filter((item) => item.kind === "required").map((item) => ({ item, reading: readingOf(item.text, words) }));
+  return items
+    .filter((item) => item.kind === "preferred")
+    .flatMap((item) => {
+      const reading = readingOf(item.text, words);
+      const match = required.find((candidate) => candidate.item.container === item.container && repeats(reading, candidate.reading));
+      return match === undefined ? [] : [{ offset: item.offset, values: { item: item.text, required: match.item.text } }];
+    });
+};

package/src/structure/share-column.ts

@@ -0,0 +1,25 @@
+/**
+ * 表の列の見出しが、それだけで全体を分けた割合の列と名指すか（割合、配点、Weight）。これらの語は文の中では行ごとの率にも使うので、
+ * 見出しの升がその語だけ（単位の括弧と % は除く）のときに限る。
+ */
+
+/** 見出しの升から外す飾り: 括弧に入れた単位（(%)、（％）、[%]）、% の記号、強調の印。単位でない括弧（（達成率））は残す。 */
+const DECORATION = /[(（［[](?:\s|[%％]|percent|pct)*[)）］\]]|[%％*_]/giu;
+const LATIN = /^\p{ASCII}+$/u;
+const WORD_BREAK = /[^\p{L}\p{N}]+/u;
+
+const bareCell = (cell: string): string => cell.replace(DECORATION, "").trim().toLowerCase();
+
+export const isShareColumn = (cell: string, columnLabels: readonly string[]): boolean => {
+  const bare = bareCell(cell);
+  return bare.length > 0 && columnLabels.some((label) => label.toLowerCase() === bare);
+};
+
+/** 英字の語は語の切れ目で探す（rate を separate に当てない）。日本語の語は文字列の中で探す。 */
+const mentions = (text: string, word: string): boolean => {
+  const lowered = word.toLowerCase();
+  if (!LATIN.test(lowered)) return text.includes(word);
+  return ` ${text.toLowerCase().split(WORD_BREAK).join(" ")} `.includes(` ${lowered} `);
+};
+
+export const mentionsAny = (text: string, words: readonly string[]): boolean => words.some((word) => mentions(text, word));