chaffjs 0.30.0 → 0.32.0

package/src/name-char-reading.ts

@@ -0,0 +1,24 @@
+/** 解析器が読みを持たない名前の字（健汰 の 汰）から、その字の名前での読みへ。語彙表 name-char-reading が言う。 */
+export type CharReadings = ReadonlyMap<string, string>;
+
+export const NO_CHAR_READINGS: CharReadings = new Map();
+
+type ReadToken = { readonly surface: string; readonly reading?: string | undefined };
+
+const isRead = (reading: string | undefined): reading is string => reading !== undefined && reading !== "";
+
+/**
+ * 語の読み。解析器の読みがあればそれ。無ければ、語の字がどれも語彙表にあるときだけ字の読みをつなぐ。一字でも読めなければ無い
+ * （読めない字を飛ばすと、別の名前を同じ読みと言ってしまう）。
+ */
+export const tokenReadingOf = (token: ReadToken, chars: CharReadings): string | undefined => {
+  if (isRead(token.reading)) return token.reading;
+  const readings = [...token.surface].map((letter) => chars.get(letter));
+  return readings.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};
+
+/** 語を並べた名前の読み。読めない語が一つでもあれば無い。 */
+export const readingOfWords = (words: readonly ReadToken[], chars: CharReadings): string | undefined => {
+  const readings = words.map((token) => tokenReadingOf(token, chars));
+  return words.length > 0 && readings.every(isRead) ? readings.join("") : undefined;
+};

package/src/name-line-block.ts

@@ -0,0 +1,40 @@
+import type { Token } from "./plugin.ts";
+
+/**
+ * 1 行に 1 つずつ書いた短い行の並び（署名の 名前／役職／学校名、住所の行）。Markdown では一つの段落、一つの文になり、名前の
+ * 語の続きが次の行の頭の語（Mr Daniel Whitfield⏎Head of Year 9 の Head）まで伸びる。行が文の終わりの記号で終わらず、どの行も
+ * 短く、小文字で始まらず、行の数も少ないときだけ、行ごとに名前を読む。折り返したふつうの文は最後の行が文の終わりの記号で
+ * 終わるか、行が長いか、小文字で始まる行を持つ。
+ */
+
+/** 行ごとに読む行の語の数の上限。折り返した文の行はこれより長い。 */
+const MAX_LINE_WORDS = 6;
+/** 行ごとに読む文の行の数の上限。署名や住所は収まる。長い一覧の一語の地名は、分けるとふつうの語と一字違いに見える。 */
+const MAX_BLOCK_LINES = 8;
+const SENTENCE_END = /[.!?。！？:;：；]["'”’)）]*$/u;
+const LOWERCASE_START = /^\p{Ll}/u;
+const NEWLINE = /\r?\n/u;
+const WORD = /\S+/gu;
+
+const isItemLine = (line: string): boolean =>
+  line !== "" && !SENTENCE_END.test(line) && !LOWERCASE_START.test(line) && (line.match(WORD) ?? []).length <= MAX_LINE_WORDS;
+
+/** 文が、短い行を 1 行に 1 つずつ並べたものか。 */
+export const isLineBlock = (text: string): boolean => {
+  const lines = text
+    .trim()
+    .split(NEWLINE)
+    .map((line) => line.trim());
+  return lines.length >= 2 && lines.length <= MAX_BLOCK_LINES && lines.every(isItemLine);
+};
+
+/** 語を、あいだに改行を挟むところで分けた並び。text は start の位置から始まる文字列で、語の範囲を覆う。 */
+export const tokensByLine = (tokens: readonly Token[], text: string, start = 0): Token[][] =>
+  tokens.reduce<Token[][]>((lines, token, index) => {
+    const previous = tokens[index - 1];
+    const breaks = previous !== undefined && NEWLINE.test(text.slice(previous.span.end - start, token.span.start - start));
+    const current = lines.at(-1);
+    if (current === undefined || breaks) lines.push([token]);
+    else current.push(token);
+    return lines;
+  }, []);

package/src/name-lookalike-chars.ts

@@ -0,0 +1,53 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 人の名前で、形が似ていて取り違えやすい別の字（太 と 大、未 と 末）。どの字が似ているかは語彙表 name-lookalike-char が組（group）
+// ごとに言う。読みが違うので、読みの同じ名前の見方では比べられない。
+
+/** 字から、その組の代表の字へ。 */
+export type LookalikeChars = ReadonlyMap<string, string>;
+
+export const NO_LOOKALIKES: LookalikeChars = new Map();
+
+const isSameGroup = (left: string, right: string, lookalikes: LookalikeChars): boolean => {
+  const group = lookalikes.get(left);
+  return group !== undefined && group === lookalikes.get(right);
+};
+
+/** 字数が同じで、同じ位置の一字だけが違い、その二字が同じ組にある（山本 健太 と 山本 健大）。 */
+export const isLookalikeApart = (left: string, right: string, lookalikes: LookalikeChars): boolean => {
+  const [leftChars, rightChars] = [[...left], [...right]];
+  if (leftChars.length !== rightChars.length) return false;
+  const differ = leftChars.flatMap((char, index) => (char === rightChars[index] ? [] : [index]));
+  const [at] = differ;
+  return differ.length === 1 && at !== undefined && isSameGroup(leftChars[at] ?? "", rightChars[at] ?? "", lookalikes);
+};
+
+/** 書き方ごとの最初の現れと数。姓と名のそろった（二語以上の）人の名前だけ。 */
+const fullPersonNamesOf = (mentions: readonly NameMention[]): Map<string, { readonly first: NameMention; readonly count: number }> => {
+  const names = new Map<string, { readonly first: NameMention; readonly count: number }>();
+  mentions
+    .filter((mention) => mention.person === true && mention.words.length >= 2)
+    .forEach((mention) => {
+      const known = names.get(mention.surface);
+      names.set(mention.surface, { first: known?.first ?? mention, count: (known?.count ?? 0) + 1 });
+    });
+  return names;
+};
+
+export type LookalikeSlip = { readonly mention: NameMention; readonly usual: string };
+
+/**
+ * 姓と名のそろった人の名前が、形の似た別の字一字だけで違う所（山本 健太 と 山本 健大）。兄弟（健太 と 健大）もありうるので、
+ * 多いほうが二度以上、少ないほうが一度だけのときに限る。相手が二つあれば多いほう、同数なら先に書いたほう。
+ */
+export const lookalikeSlipsIn = (mentions: readonly NameMention[], lookalikes: LookalikeChars): LookalikeSlip[] => {
+  const names = [...fullPersonNamesOf(mentions).values()];
+  return names
+    .filter((name) => name.count === 1)
+    .flatMap((slip) => {
+      const usual = names
+        .filter((other) => other.count >= 2 && isLookalikeApart(slip.first.surface, other.first.surface, lookalikes))
+        .toSorted((left, right) => right.count - left.count || left.first.offset - right.first.offset)[0];
+      return usual === undefined ? [] : [{ mention: slip.first, usual: usual.first.surface }];
+    });
+};

package/src/name-neighbours.ts

@@ -0,0 +1,58 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 解析器が名前の一語を名前と読まなかった所を、隣の語と合わせて名前の現れにする（to Rachel Whitford の Rachel）。
+
+/** 隣の語を探す範囲（UTF-16 の単位）。 */
+const NEIGHBOUR_LOOKBACK = 40;
+/** 隣の語の外側の記号（(Rachel、Floyd.）。名前の側の記号（Rachel, Whitford の ,）は語を切るので残す。 */
+const MARK = /\p{P}/u;
+const withoutLeadingMarks = (word: string): string => {
+  const chars = [...word];
+  const start = chars.findIndex((char) => !MARK.test(char));
+  return start < 0 ? "" : chars.slice(start).join("");
+};
+const withoutTrailingMarks = (word: string): string => {
+  const chars = [...word];
+  return chars.slice(0, chars.findLastIndex((char) => !MARK.test(char)) + 1).join("");
+};
+
+const wordBeforeAt = (source: string, offset: number): string | undefined => {
+  if (source.charAt(offset - 1) !== " ") return undefined;
+  const from = Math.max(0, offset - 1 - NEIGHBOUR_LOOKBACK);
+  const parts = source.slice(from, offset - 1).split(/\s/u);
+  const word = withoutLeadingMarks(parts.at(-1) ?? "");
+  return word === "" || (from > 0 && parts.length === 1) ? undefined : word;
+};
+
+const wordAfterAt = (source: string, end: number): string | undefined => {
+  if (source.charAt(end) !== " ") return undefined;
+  const word = withoutTrailingMarks(source.slice(end + 1, end + 1 + NEIGHBOUR_LOOKBACK).split(/\s/u)[0] ?? "");
+  return word === "" ? undefined : word;
+};
+
+/**
+ * 解析器が名前の一語を名前と読まなかった所（to Rachel Whitford の Rachel を動詞と読む）。空白一つで隣の語と合わせた形を、ほかの所で
+ * 名前と読めていれば、その形の現れと見る。隣の語がほかの名前の現れに入るなら合わせない。
+ */
+export const withKnownNeighbours = (mentions: readonly NameMention[], source: string): NameMention[] => {
+  const known = new Set(mentions.filter((mention) => mention.words.length >= 2).map((mention) => mention.surface));
+  const taken = (start: number, end: number): boolean => mentions.some((mention) => mention.offset < end && start < mention.offset + mention.surface.length);
+  return mentions.map((mention) => {
+    const end = mention.offset + mention.surface.length;
+    const before = wordBeforeAt(source, mention.offset);
+    const after = wordAfterAt(source, end);
+    if (before !== undefined && known.has(`${before} ${mention.surface}`) && !taken(mention.offset - 1 - before.length, mention.offset - 1)) {
+      return {
+        ...mention,
+        surface: `${before} ${mention.surface}`,
+        offset: mention.offset - 1 - before.length,
+        reading: undefined,
+        words: [before, ...mention.words],
+      };
+    }
+    if (after !== undefined && known.has(`${mention.surface} ${after}`) && !taken(end + 1, end + 1 + after.length)) {
+      return { ...mention, surface: `${mention.surface} ${after}`, reading: undefined, words: [...mention.words, after] };
+    }
+    return mention;
+  });
+};

package/src/name-ordinary-word.ts

@@ -0,0 +1,68 @@
+import type { Token } from "./plugin.ts";
+import type { NameMention } from "./name-variants.ts";
+import { escapeRegExp } from "./orthography.ts";
+
+// 名前と読んだ一語が、ふつうの語でもある所（文頭や題の Green、国の名の Greek）。二つのふつうの語（Green と Greek、Course と
+// Curse）は一字違いでも別の語で、同じ名前の書き損じではない。
+
+/** 解析器が名前と読んだ語が、小文字で書けばふつうの語か（adapter の OrdinaryWord=Yes）。 */
+export const isOrdinaryToken = (token: Token): boolean => token.features?.["OrdinaryWord"] === "Yes";
+
+/** 文書が word を敬称か肩書きの後ろに書くか（Mr. Green、Senator Marsh）。書けば、その語を人の名前に使っている。 */
+export const isTitledIn = (source: string, titles: readonly string[], word: string): boolean =>
+  titles.some((title) => new RegExp(`(?<![\\p{L}\\p{N}])${escapeRegExp(title)}\\s+${escapeRegExp(word)}(?![\\p{L}\\p{N}])`, "u").test(source));
+
+/** 人を書く欄の行の頭の、Markdown の印（箇条書き、引用、見出し、太字）。 */
+const LINE_MARKS = /^[\s>*#+-]*(?:\*\*|__)?/u;
+/** 欄の後ろの名前: 大文字で始まる一語から三語（Ellen J. Marsh）。行の終わりか、「,」か括弧の前まで。 */
+const FIELD_NAME = /^(?:\*\*|__)?[ \t]*(\p{Lu}[\p{L}'’.-]*(?:[ \t]+\p{Lu}[\p{L}'’.-]*){0,2})[ \t]*(?:[,(（].*)?$/u;
+
+/** 行が人を書く欄（Customer: Ellen Marsh）なら、欄の後ろの名前の最後の語（姓）。欄の語は、行の頭の「:」の前の語まるごとで照らす。 */
+const labelledSurname = (line: string, labels: ReadonlySet<string>): string | undefined => {
+  const colon = line.search(/[:：]/u);
+  if (colon < 0) return undefined;
+  const label = line
+    .slice(0, colon)
+    .replace(LINE_MARKS, "")
+    .replace(/(?:\*\*|__)$/u, "")
+    .trim()
+    .toLowerCase();
+  if (!labels.has(label)) return undefined;
+  return FIELD_NAME.exec(line.slice(colon + 1))?.[1]
+    ?.split(/[ \t]+/u)
+    .at(-1)
+    ?.replace(/\.$/u, "");
+};
+
+/**
+ * 文書が word を、人を書く欄の名前の最後の語（姓）に書くか（Customer: Ellen Marsh、Client: Marsh）。書けば、その語を人の名前に
+ * 使っている。欄の後ろの最後の語だけを見るので、Name: Green Valley Farm の Green は名前に使った語にならない。
+ */
+const labelledSurnamesIn = (source: string, labels: readonly string[]): ReadonlySet<string> => {
+  const wanted = new Set(labels.map((label) => label.toLowerCase()));
+  return new Set(wanted.size === 0 ? [] : source.split(/\r?\n/u).flatMap((line) => labelledSurname(line, wanted) ?? []));
+};
+
+export const isLabelledIn = (source: string, labels: readonly string[], word: string): boolean => labelledSurnamesIn(source, labels).has(word);
+
+/**
+ * 一語の名前の現れのうち、その語がふつうの語でもあり（ordinaryStarts は、そういう語の頭の位置）、文書のどこでも敬称や肩書きの
+ * 後ろにも、人を書く欄（labels）の姓にも書かないものに ordinary を付ける。同じ形の現れが一つでもそうでなければ、その形のどの現れにも付けない。
+ */
+export const withOrdinaryWords = (
+  mentions: readonly NameMention[],
+  ordinaryStarts: ReadonlySet<number>,
+  source: string,
+  titles: readonly string[],
+  labels: readonly string[] = [],
+): NameMention[] => {
+  const isOrdinary = (mention: NameMention): boolean => {
+    const [word] = mention.words;
+    return mention.words.length === 1 && word !== undefined && ordinaryStarts.has(mention.offset);
+  };
+  const named = new Set(mentions.filter((mention) => !isOrdinary(mention)).map((mention) => mention.surface));
+  const ordinarySurfaces = new Set(mentions.filter((mention) => !named.has(mention.surface) && isOrdinary(mention)).map((mention) => mention.surface));
+  const labelled = labelledSurnamesIn(source, labels);
+  const neverNamed = new Set([...ordinarySurfaces].filter((surface) => !isTitledIn(source, titles, surface) && !labelled.has(surface)));
+  return mentions.map((mention) => (neverNamed.has(mention.surface) ? { ...mention, ordinary: true } : mention));
+};

package/src/name-person.ts

@@ -0,0 +1,31 @@
+import type { Token } from "./plugin.ts";
+
+// 固有名詞の続きが人の名前と読めるか。解析器の人名の印か、後ろの敬称で決める。
+
+/** 人名と読む解析器の印（UD の NameType: 姓 Sur、名 Giv、どちらとも言えない人名 Prs）。 */
+const PERSON_TYPES: ReadonlySet<string> = new Set(["Sur", "Giv", "Prs"]);
+
+/** 行の中の空き（半角・全角の空白、タブ）。名前と敬称のあいだに置く（森下 千尋 様）。改行は越えない。 */
+const INLINE_BLANK = /^[\t\p{Zs}]+$/u;
+
+/** 名前の後ろの語。行の中の空きを一つ越える（森下 千尋 様 の 様）。 */
+const wordAfter = (tokens: readonly Token[], last: Token): Token | undefined => {
+  const at = tokens.indexOf(last) + 1;
+  const next = tokens[at];
+  return next !== undefined && INLINE_BLANK.test(next.surface) ? tokens[at + 1] : next;
+};
+
+/** 語の後ろに敬称（様、さん、氏）が付くか。行の中の空きを挟んでもよい。 */
+export const isFollowedBySuffix = (token: Token, tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const next = wordAfter(tokens, token);
+  return next !== undefined && suffixes.includes(next.surface);
+};
+
+/**
+ * 人の名前か。解析器が人名と読む語を含むか、後ろに敬称が付く。解析器は名を地名と読むことがある（千尋 を Geo）ので、敬称は空白を
+ * 挟んでも見る。
+ */
+export const isPersonRun = (run: readonly Token[], tokens: readonly Token[], suffixes: readonly string[]): boolean => {
+  const last = run.at(-1);
+  return run.some((token) => PERSON_TYPES.has(token.features?.["NameType"] ?? "")) || (last !== undefined && isFollowedBySuffix(last, tokens, suffixes));
+};

package/src/name-separator.ts

@@ -0,0 +1,48 @@
+import type { Boundary } from "./orthography.ts";
+import type { Span, Token } from "./plugin.ts";
+
+/** 名前を空白で並べた行（署名・連絡先・所属の行）に出る品詞。助詞・動詞・助動詞・連体詞が一つでもあれば、その行は文。 */
+const NAME_LINE_POS = new Set(["NOUN", "PROPN", "NUM", "PUNCT", "SYM"]);
+
+/** units は部署・拠点・役目の名前を閉じる語（語彙表 organization-unit）、forms は会社の形の語（語彙表 company-form）。 */
+export type OrganizationWords = { readonly units: ReadonlySet<string>; readonly forms: readonly string[] };
+
+/** at を含む行の範囲。 */
+const lineAround = (text: string, at: number): Span => {
+  const end = text.indexOf("\n", at);
+  return { start: text.lastIndexOf("\n", at - 1) + 1, end: end === -1 ? text.length : end };
+};
+
+/** 語を区切る空白。 */
+const WORD_BREAKS = [" ", "\t", "\n", "\r", "\u00a0", "\u3000"];
+
+/** end の前の、空白で区切った語の頭の位置。 */
+const wordStart = (text: string, end: number): number => Math.max(...WORD_BREAKS.map((space) => text.slice(0, end).lastIndexOf(space))) + 1;
+
+/** start からの、空白で区切った語の終わりの位置。 */
+const wordEnd = (text: string, start: number): number =>
+  Math.min(...WORD_BREAKS.map((space) => text.indexOf(space, start)).map((at) => (at === -1 ? text.length : at)));
+
+/** span の中の語。tokens は文書全体の座標で、base は text の先頭の位置。 */
+const tokensIn = (tokens: readonly Token[], span: Span, base: number): Token[] =>
+  tokens.filter((token) => token.span.start >= base + span.start && token.span.end <= base + span.end);
+
+/** 行の語がどれも名前の語か。品詞の無い行は名前の並びと読まない。 */
+const isNameLine = (lineTokens: readonly Token[]): boolean => lineTokens.length > 0 && lineTokens.every((token) => NAME_LINE_POS.has(token.pos));
+
+/** 空白で区切った語が、組織の名前か。最後の語が部署・拠点・役目の語（経営企画部、IR担当）か、会社の形の語で始まるか終わる（株式会社ABC）。 */
+const isOrganizationName = (word: string, wordTokens: readonly Token[], words: OrganizationWords): boolean =>
+  words.units.has(wordTokens.at(-1)?.surface ?? "") || words.forms.some((form) => word.length > form.length && (word.startsWith(form) || word.endsWith(form)));
+
+/**
+ * 「株式会社あおば電子 経営企画部 IR担当」「東京本社 PR室」のように、名前だけを空白で並べた行で、空白の両側がどちらも組織の名前のときの空白。
+ * 名前と名前の区切りで、英字の前後の空け方ではない。文の中の空白（この IT システムは）や、組織の名前でない語のあいだ（生成AI 活用事例、Patch リリース）は区切りと読まない。
+ * boundary は空けた英字の境目（text[offset] が空白）。tokens は文書全体の座標で、base は text の先頭の位置。
+ */
+export const isNameSeparator = (text: string, boundary: Boundary, tokens: readonly Token[] | undefined, base: number, words: OrganizationWords): boolean => {
+  if (tokens === undefined || boundary.kind !== "letter" || !boundary.spaced) return false;
+  const before = { start: wordStart(text, boundary.offset), end: boundary.offset };
+  const after = { start: boundary.offset + 1, end: wordEnd(text, boundary.offset + 1) };
+  const isName = (span: Span): boolean => isOrganizationName(text.slice(span.start, span.end), tokensIn(tokens, span, base), words);
+  return isName(before) && isName(after) && isNameLine(tokensIn(tokens, lineAround(text, boundary.offset), base));
+};

package/src/name-spelling-chars.ts

@@ -0,0 +1,34 @@
+import type { NameMention } from "./name-variants.ts";
+
+// 一語の名前の中で、同じ音を二通りに書く字（桜ヶ丘・桜ケ丘・桜が丘、霞ヶ関・霞が関）。どの字が同じかは語彙表 name-spelling-char が
+// 組（group）ごとに言う。漢字に挟まれた字だけを寄せる。かなの語の中の字は寄せない。名前は解析器が一語と読んだもの
+// （霞が関）に限る。桜・が・丘 と読む書き方を本文にそのまま探すと、助詞の が（桜が丘を彩る）を名前と取り違える。
+
+/** 字から、その組の代表の字へ。 */
+export type SpellingChars = ReadonlyMap<string, string>;
+
+/**
+ * 名前の中の同じ音の字を比べる材料。chars はその字の組。alsoWritten は、この比べ方にだけ加える名前の現れ（表の升の名前）。升の名前をほかの見方に加えると、表の識別子（contentType）を本文の名前（Content-Type）と比べてしまう。
+ */
+export type SpellingInput = { readonly chars: SpellingChars; readonly alsoWritten: readonly NameMention[] };
+
+export const NO_SPELLING: SpellingInput = { chars: new Map(), alsoWritten: [] };
+
+const HAN = /^\p{Script=Han}$/u;
+
+const isBetweenHan = (chars: readonly string[], index: number): boolean => HAN.test(chars[index - 1] ?? "") && HAN.test(chars[index + 1] ?? "");
+
+/** 漢字に挟まれた、組のある字の位置。 */
+const foldableAt = (chars: readonly string[], spelling: SpellingChars): number[] =>
+  chars.flatMap((char, index) => (spelling.has(char) && isBetweenHan(chars, index) ? [index] : []));
+
+/** 漢字に挟まれた組の字を、組の代表に寄せた形。寄せる字が無ければ書いたまま。 */
+export const foldSpelling = (surface: string, spelling: SpellingChars): string => {
+  const chars = [...surface];
+  const at = new Set(foldableAt(chars, spelling));
+  return chars.map((char, index) => (at.has(index) ? (spelling.get(char) ?? char) : char)).join("");
+};
+
+/** 比べる形。漢字に挟まれた組の字を含む名前だけが、寄せた形を一つ持つ。含まない名前（Content-Type）はこの比べ方に入らない。 */
+export const foldedKeysOf = (surface: string, spelling: SpellingChars): string[] =>
+  foldableAt([...surface], spelling).length > 0 ? [foldSpelling(surface, spelling)] : [];