chaffjs 0.33.0 → 0.35.0

package/src/name-variants.ts

@@ -2,6 +2,8 @@ import type { Token } from "./plugin.ts";
 import { escapeRegExp } from "./orthography.ts";
 import { nameCueAt, type NameCue, type NameCues } from "./name-cue.ts";
 import { isNearSurname } from "./surname-near.ts";
+import { isEndWordSlip, isWordFormOf, NO_WORD_USE, type WordUse } from "./name-end-letter.ts";
+import { areOtherPeople, givenNamesBySurface, type GivenNames } from "./name-given-before.ts";
 import { foldedKeysOf, NO_SPELLING, type SpellingInput } from "./name-spelling-chars.ts";
 import { NO_CHAR_READINGS, readingOfWords } from "./name-char-reading.ts";
 import { isPersonRun } from "./name-person.ts";
@@ -15,7 +17,9 @@ import { heavierFirst, outweighs, type NameWeight } from "./name-weight.ts";
  * words は名前の語（記号を除く）。読みが同じ二つの名前が、どの語で違うかを見るため。person は人の名前と読めるもの（解析器が
  * 人名と読むか、敬称が付く）。cue は前後の語から見た名前らしさ（name-cue.ts）。ordinary は、ふつうの語でもある一語の名前で、
  * 文書がその形をどこでも名前に使わないもの（name-ordinary-word.ts）。labelled は、人を書く欄（氏名：、Contractor:）に書いた名前
- * （person-field.ts）。
+ * （person-field.ts）。givenNameReading は、空白を挟んだ姓と名の名を、名の中での字の読みで読み直した読み（name-char-reading.ts の
+ * givenNameReadingOf）。解析器が名を別の読みに切ったとき（建太 を タテフトシ）のもう一通りの読み。givenName は、名前のすぐ前に
+ * 書いた名（Jeffrey D. Walker の Jeffrey、name-given-before.ts）。
  */
 export type NameMention = {
   readonly surface: string;
@@ -26,6 +30,8 @@ export type NameMention = {
   readonly cue?: NameCue;
   readonly ordinary?: boolean;
   readonly labelled?: boolean;
+  readonly givenNameReading?: string | undefined;
+  readonly givenName?: string | undefined;
 };
 
 export type NameVariant = {
@@ -163,8 +169,12 @@ export const nameKey = (surface: string): string =>
  */
 export type NameEvidence = { readonly person: boolean; readonly named: boolean; readonly nameLike: boolean };
 
-/** readings は書き方の現れの読みのすべて。解析器は同じ字を所によって別に読む（佐伯 を サエキ と サイキ）。 */
-type Tally = NameEvidence & NameWeight & { readonly surface: string; readonly first: NameMention; readonly readings: readonly string[] };
+/**
+ * readings は書き方の現れの読みのすべて。解析器は同じ字を所によって別に読む（佐伯 を サエキ と サイキ）。givenNameReadings は
+ * 現れの givenNameReading のすべて。
+ */
+type Tally = NameEvidence &
+  NameWeight & { readonly surface: string; readonly first: NameMention; readonly readings: readonly string[]; readonly givenNameReadings: readonly string[] };
 
 const readingsWith = (readings: readonly string[], reading: string | undefined): readonly string[] =>
   reading === undefined || readings.includes(reading) ? readings : [...readings, reading];
@@ -184,11 +194,20 @@ const talliesOf = (mentions: readonly NameMention[]): Tally[] => {
     tallies.set(
       mention.surface,
       tally === undefined
-        ? { surface: mention.surface, first: mention, count: 1, readings: readingsWith([], mention.reading), labelled: mention.labelled === true, ...evidence }
+        ? {
+            surface: mention.surface,
+            first: mention,
+            count: 1,
+            readings: readingsWith([], mention.reading),
+            givenNameReadings: readingsWith([], mention.givenNameReading),
+            labelled: mention.labelled === true,
+            ...evidence,
+          }
         : {
             ...tally,
             count: tally.count + 1,
             readings: readingsWith(tally.readings, mention.reading),
+            givenNameReadings: readingsWith(tally.givenNameReadings, mention.givenNameReading),
             person: tally.person || evidence.person,
             named: tally.named || evidence.named,
             nameLike: tally.nameLike || evidence.nameLike,
@@ -268,14 +287,17 @@ const isSwapOrReplace = (left: string, right: string): boolean => {
 const isInnerDrop = (longer: string, shorter: string): boolean =>
   [...longer].some((_char, index) => index > 0 && index < longer.length - 1 && longer.slice(0, index) + longer.slice(index + 1) === shorter);
 
-/** 二つの語が一字違いか。英字だけの、長さ 5 以上の語で。 */
-export const isNearWord = (left: string, right: string): boolean => {
-  if (left === right || !LATIN_WORD.test(left) || !LATIN_WORD.test(right) || Math.min(left.length, right.length) < MIN_NEAR_LENGTH) return false;
+/** 二つの英字だけの語が一字違いか（置き換え・隣どうしの入れ替え・中の抜け）。長さは問わない。 */
+const isOneLetterApart = (left: string, right: string): boolean => {
+  if (left === right || !LATIN_WORD.test(left) || !LATIN_WORD.test(right)) return false;
   if (left.length === right.length) return isSwapOrReplace(left, right);
   if (left.length === right.length + 1) return isInnerDrop(left, right);
   return right.length === left.length + 1 && isInnerDrop(right, left);
 };
 
+/** 二つの語が一字違いか。英字だけの、長さ 5 以上の語で。 */
+export const isNearWord = (left: string, right: string): boolean => Math.min(left.length, right.length) >= MIN_NEAR_LENGTH && isOneLetterApart(left, right);
+
 /** 語の一つを伏せた形。ほかの語が同じ二つの名前は、同じ形を一つ持つ。 */
 const maskedKeys = (tally: Tally): string[] => {
   const words = wordsOf(tally.surface);
@@ -291,13 +313,37 @@ const differingWords = (left: Tally, right: Tally): readonly [string, string] |
 };
 
 /** 一語だけが一字違いで、相手のほうが重い（outweighs）。どちらもふつうの語（Green と Greek）なら、別の二つの語。 */
-const isSlipOf = (tally: Tally, other: Tally): boolean => {
-  if (!outweighs(other, tally) || (tally.first.ordinary === true && other.first.ordinary === true)) return false;
-  const words = differingWords(tally, other);
-  return words !== undefined && isNearWord(...words);
-};
+const isSlipOf =
+  (use: WordUse): Alike =>
+  (tally, other) => {
+    if (!outweighs(other, tally) || (tally.first.ordinary === true && other.first.ordinary === true)) return false;
+    const words = differingWords(tally, other);
+    return words !== undefined && isNearWord(...words) && !isWordFormOf(...words, use);
+  };
 
-const nearVariants = (tallies: readonly Tally[]): NameVariant[] => variantsIn(groupBy(tallies, maskedKeys), "near", isSlipOf, true);
+/**
+ * 二語以上の名前の一語だけが、終わりの一字の抜けか足し（Rachel Whitmore と Rachel Whitmor）か、最後の語（姓）が四字でも一字違い
+ * （Daniel Reyes と Daniel Reys）で、相手のほうが重い（outweighs）。違う語のどちらかがふつうの語なら語の形の違い。
+ */
+const isEndSlipOf =
+  (use: WordUse): Alike =>
+  (tally, other) => {
+    const [words, others] = [wordsOf(tally.surface), wordsOf(other.surface)];
+    const at = words.findIndex((word, index) => word !== others[index]);
+    const [word, usual] = [words[at], others[at]];
+    if (!outweighs(other, tally) || words.length < 2 || words.length !== others.length || word === undefined || usual === undefined) return false;
+    return !use.ordinary.has(word) && !use.ordinary.has(usual) && isEndWordSlip(words, at, usual, use, isOneLetterApart);
+  };
+
+const nearVariants = (tallies: readonly Tally[], use: WordUse, givenNames: GivenNames): NameVariant[] => {
+  const [isSlip, isEndSlip] = [isSlipOf(use), isEndSlipOf(use)];
+  return variantsIn(
+    groupBy(tallies, maskedKeys),
+    "near",
+    (tally, other) => !areOtherPeople(givenNames.get(tally.surface), givenNames.get(other.surface)) && (isSlip(tally, other) || isEndSlip(tally, other)),
+    true,
+  );
+};
 
 /**
  * 名が同じで姓だけが二字ほど違う人の名前（Rachel Whitford と Rachel Whitfield）。一字違い（near）より遠いので、名と姓の二語以上
@@ -343,7 +389,7 @@ const oneCharApart = (left: string, right: string): boolean => {
 
 /**
  * 読みが同じ人の名前が、一字だけ違う（松本 と 松元）。読みの同じ別の姓（伊藤 と 伊東）もあるので、相手のほうが重い（outweighs）
- * ときに限る。
+ * ときに限る。名を名の中での字の読みで読み直した読み（健太 と 建太 の ケンタ）でも比べる。
  */
 const isPersonSlipOf = (tally: Tally, other: Tally): boolean => outweighs(other, tally) && oneCharApart(tally.surface, other.surface);
 
@@ -351,7 +397,7 @@ const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
   variantsIn(
     groupBy(
       tallies.filter((tally) => tally.person),
-      (tally) => tally.readings,
+      (tally) => [...tally.readings, ...tally.givenNameReadings],
     ),
     "reading",
     isPersonSlipOf,
@@ -360,9 +406,14 @@ const personReadingVariants = (tallies: readonly Tally[]): NameVariant[] =>
 
 /**
  * 同じ名前の、少ないほうの書き方。書き方ごとに最初の現れを一つ。同じ現れを二つの見方が言えば、先の見方だけ。chars は字体の
- * 違う同じ字の組（語彙表 name-variant-char）。
+ * 違う同じ字の組（語彙表 name-variant-char）。use は文書での英字の語の使い方。
  */
-export const nameVariants = (mentions: readonly NameMention[], chars: VariantChars = new Map(), spelling: SpellingInput = NO_SPELLING): NameVariant[] => {
+export const nameVariants = (
+  mentions: readonly NameMention[],
+  chars: VariantChars = new Map(),
+  spelling: SpellingInput = NO_SPELLING,
+  use: WordUse = NO_WORD_USE,
+): NameVariant[] => {
   const tallies = talliesOf(mentions);
   const found = [
     ...variantsIn(
@@ -378,7 +429,7 @@ export const nameVariants = (mentions: readonly NameMention[], chars: VariantCha
       "reading",
       oneWordApart,
     ),
-    ...nearVariants(tallies),
+    ...nearVariants(tallies, use, givenNamesBySurface(mentions)),
     ...surnameVariants(tallies),
     ...characterVariants(tallies, chars),
     ...personReadingVariants(tallies),

package/src/name-word-order.ts

@@ -41,12 +41,25 @@ const CAPITALISED = "\\p{Lu}[\\p{L}'’-]*";
 
 const FIRST_WORD = new RegExp(`^${CAPITALISED}[ \\t]+`, "u");
 
+/** 小さな語の並び。冠詞（the）は前置詞（of、for）のすぐ後ろにだけ立つ（Bank of the West）。 */
+const joinerPattern = (joiners: readonly string[], articles: readonly string[]): string => {
+  if (joiners.length === 0) return "";
+  const article = articles.length === 0 ? "" : `(?:(?:${articles.map(escapeRegExp).join("|")})[ \\t]+)?`;
+  return `(?:(?:${joiners.map(escapeRegExp).join("|")})[ \\t]+${article})*`;
+};
+
 /**
- * 大文字で始まる語が二つ以上並んだ所（Foundations of Statistics）。語のあいだに小さな語（of）を挟んでよい。文の頭の語は、
- * 文の頭だから大文字のことがあるので、外す（Take Data Lab の Take）。
+ * 大文字で始まる語が二つ以上並んだ所（Foundations of Statistics）。語のあいだに小さな語（of、of the）を挟んでよい。冠詞だけを
+ * 挟んだ二つの語（this Agreement the Stockholders）は、句の切れ目をまたぐので一つの名前にしない。文の頭の語は、文の頭だから
+ * 大文字のことがあるので、外す（Take Data Lab の Take）。
  */
-export const titleCaseSpans = (text: string, joiners: readonly string[], isSentenceStart: (offset: number) => boolean = () => false): NameSpan[] => {
-  const joiner = joiners.length === 0 ? "" : `(?:(?:${joiners.map(escapeRegExp).join("|")})[ \\t]+)*`;
+export const titleCaseSpans = (
+  text: string,
+  joiners: readonly string[],
+  isSentenceStart: (offset: number) => boolean = () => false,
+  articles: readonly string[] = [],
+): NameSpan[] => {
+  const joiner = joinerPattern(joiners, articles);
   const pattern = new RegExp(`(?<![\\p{L}'’-])${CAPITALISED}(?:[ \\t]+${joiner}${CAPITALISED})+`, "gu");
   return [...text.matchAll(pattern)].map((found) => {
     const start = found.index ?? 0;
@@ -112,16 +125,33 @@ export const orderNamesOf = (text: string, spans: readonly NameSpan[], words: re
     .toSorted((left, right) => left.offset - right.offset);
 };
 
-type Tally = { readonly first: OrderName; readonly count: number; readonly anchored: boolean };
-
-const talliesOf = (names: readonly OrderName[]): Tally[] => [
-  ...names
-    .reduce<Map<string, Tally>>((tallies, name) => {
-      const known = tallies.get(name.surface);
-      return tallies.set(name.surface, { first: known?.first ?? name, count: (known?.count ?? 0) + 1, anchored: (known?.anchored ?? false) || name.anchored });
-    }, new Map())
-    .values(),
-];
+type Tally = { readonly first: OrderName; readonly count: number; readonly anchored: boolean; readonly offsets: readonly number[] };
+
+/** 書き方ごとの、現れの位置のすべて。 */
+const offsetsBySurface = (names: readonly OrderName[]): Map<string, number[]> =>
+  names.reduce((offsets, name) => {
+    const known = offsets.get(name.surface);
+    if (known === undefined) offsets.set(name.surface, [name.offset]);
+    else known.push(name.offset);
+    return offsets;
+  }, new Map<string, number[]>());
+
+const talliesOf = (names: readonly OrderName[]): Tally[] => {
+  const offsets = offsetsBySurface(names);
+  return [
+    ...names
+      .reduce<Map<string, Tally>>((tallies, name) => {
+        const known = tallies.get(name.surface);
+        return tallies.set(name.surface, {
+          first: known?.first ?? name,
+          count: (known?.count ?? 0) + 1,
+          anchored: (known?.anchored ?? false) || name.anchored,
+          offsets: offsets.get(name.surface) ?? [],
+        });
+      }, new Map())
+      .values(),
+  ];
+};
 
 /** 多いほうが前。同じ数なら先に書いたほうが前。 */
 const byUse = (left: Tally, right: Tally): number => right.count - left.count || left.first.offset - right.first.offset;
@@ -135,15 +165,30 @@ export const isReordered = (left: OrderName, right: OrderName): boolean =>
   !left.surface.includes(right.surface) &&
   !right.surface.includes(left.surface);
 
+/** 文の番号。同じ文の二つの書き方を見分けるため。 */
+export type SentenceOf = (offset: number) => number;
+
+/** 二つの書き方を、どこかで同じ文に並べて書いたか（“Request Additional Time” or “Additional Time Requests”）。 */
+const sharesSentence = (left: Tally, right: Tally, sentenceOf: SentenceOf): boolean => {
+  const sentences = new Set(left.offsets.map(sentenceOf));
+  return right.offsets.some((offset) => sentences.has(sentenceOf(offset)));
+};
+
 /**
  * 多く使った書き方と同じ語を違う順に並べた名前。少ないほうを一つずつ指す。二つのどちらかが名前として書いた所（anchored）に
- * あるときだけ。surfaces は表の升まるごとの書き方で、その書き方の名前も anchored と見る。
+ * あるときだけ。surfaces は表の升まるごとの書き方で、その書き方の名前も anchored と見る。同じ文に並べて書いた二つは、書き手が
+ * 言い分けた別の名前（画面の二つの項目、定義する語とその中身）なので比べない。
  */
-export const wordOrderVariants = (names: readonly OrderName[], surfaces: ReadonlySet<string> = new Set()): OrderVariant[] => {
+export const wordOrderVariants = (
+  names: readonly OrderName[],
+  surfaces: ReadonlySet<string> = new Set(),
+  sentenceOf: SentenceOf = (offset) => offset,
+): OrderVariant[] => {
   const tallies = talliesOf(names).toSorted(byUse);
   const anchored = (tally: Tally): boolean => tally.anchored || surfaces.has(tally.first.surface);
+  const apart = (left: Tally, right: Tally): boolean => !sharesSentence(left, right, sentenceOf);
   return tallies.flatMap((tally, index) => {
-    const usual = tallies.slice(0, index).find((other) => (anchored(other) || anchored(tally)) && isReordered(other.first, tally.first));
+    const usual = tallies.slice(0, index).find((other) => (anchored(other) || anchored(tally)) && isReordered(other.first, tally.first) && apart(other, tally));
     return usual === undefined ? [] : [{ name: tally.first, usual: usual.first.surface }];
   });
 };

package/src/nominal-stem.ts

@@ -0,0 +1,36 @@
+import type { Token } from "./plugin.ts";
+
+/** The last kana of a verb's dictionary form, and the kana its stem form (連用形) ends in instead: 払い込む → 払い込み. */
+const STEM_ENDING: Readonly<Record<string, string>> = { う: "い", く: "き", ぐ: "ぎ", す: "し", つ: "ち", ぬ: "に", ぶ: "び", む: "み", る: "り" };
+
+/**
+ * Whether a verb is written in its stem form (払い込み from 払い込む, 申出 from 申出る). Other forms that differ from the
+ * dictionary form (ください from 下さる, 払い込ん before で) are not: they are never a noun.
+ */
+export const isStemForm = (surface: string, lemma: string): boolean => {
+  const last = lemma.slice(-1);
+  const stem = lemma.slice(0, -1);
+  if (stem === "") return false;
+  return surface === stem + (STEM_ENDING[last] ?? "\u0000") || (last === "る" && surface === stem);
+};
+
+/** What carries a verb on (払い込み、払い込んで, 払い込みます, 払い込みやすい): after these the stem form is still the verb. */
+const VERB_GOES_ON = new Set(["AUX", "SCONJ", "VERB", "ADJ"]);
+const CLAUSE_COMMA = new Set(["、", "，", ","]);
+
+/**
+ * A free noun after the stem form may begin the next clause (疾病にかかり療養のために), so the stem form stays a verb; a suffix
+ * (払込み等), or a noun the caller lists as one (受取り前), may not.
+ */
+const verbGoesOn = (next: Token, suffixes: ReadonlySet<string>): boolean =>
+  VERB_GOES_ON.has(next.pos) || CLAUSE_COMMA.has(next.surface) || (next.pos === "NOUN" && next.features?.["Bound"] !== "Yes" && !suffixes.has(next.surface));
+
+/**
+ * A verb's stem form that the verb does not go on from (払込みの期日, 申出により, 株式の買取り）): a noun the analyser read as the
+ * verb, returned as the noun it is, spelled as written. Official Japanese spells the noun and the verb apart (払込み, 払い込む),
+ * so the two are not one word in two spellings; the noun is compared with nouns. Any other token is returned as it is.
+ */
+export const asNounWhereNominal = (token: Token, next: Token | undefined, suffixes: ReadonlySet<string> = new Set()): Token => {
+  if (token.pos !== "VERB" || token.lemma === undefined || !isStemForm(token.surface, token.lemma)) return token;
+  return next !== undefined && verbGoesOn(next, suffixes) ? token : { ...token, pos: "NOUN", lemma: token.surface };
+};

package/src/number-name.ts

@@ -6,7 +6,7 @@ import type { Span, Token } from "./plugin.ts";
  * 「〒100-8916 東京都」の郵便番号、「紀尾井町1-3 東京ガーデンテラス」の番地は、後ろの空白が番号と題・項目の区切りで、「3回」「3 回」のような空け方の好みではない。
  * 空け方を数える材料にしない。
  *
- * 形で名前と読むのは六つだけ。0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
+ * 形で名前と読むのは七つだけ。桁の区切りの無い 6 桁以上の番号（口座番号 3056172）、0 で始まる組を含むハイフンつなぎの番号、※・〒や鉤括弧のすぐ後ろの番号、市・区・町まで下りた地名のすぐ後ろのハイフンつなぎの番号、
  * 文頭の階層つきの節番号（2.1、3.1.2）、続き番号になった行や番号の並ぶ箇条書きの頭の番号（白書の注、関連コード）、「問3」のように番号の前に書く語のすぐ後ろの番号。
  * 文頭でも「223 言語」「1ターン」は数量なので、階層の無い数は文頭というだけでは名前と読まない。
  * そのうえで、すぐ後ろ（空白 1 つまで）の語が数につく語（助数詞・数・助詞・助動詞）なら数量として数え続ける（「3-5 日」「26.7 万行」）。
@@ -53,8 +53,16 @@ const wordAfter = (tokens: readonly Token[], text: string, run: Span, base: numb
   return tokens.find((token) => token.span.start === base + next);
 };
 
-const isBoundToNumber = (token: Token): boolean =>
-  token.features?.["NounType"] === "Class" || token.features?.["NumType"] === "Card" || BOUND_TO_NUMBER.has(token.pos);
+/** 助数詞（NounType=Class）か数（NumType=Card）。 */
+const isCounterOrNumber = (token: Token | undefined): boolean => token?.features?.["NounType"] === "Class" || token?.features?.["NumType"] === "Card";
+
+const isBoundToNumber = (token: Token): boolean => isCounterOrNumber(token) || BOUND_TO_NUMBER.has(token.pos);
+
+/**
+ * 桁の区切りの無い、6 桁以上の数字だけの番号（口座番号 3056172 を、普通 1234567）。この大きさの数量は桁を区切るか単位を付けて書くので、
+ * 助数詞か数が続くとき（1234567円、250000 人）だけ数量と読む。助詞が続いても番号のまま。
+ */
+const PLAIN_CODE = /^\d{6,}$/u;
 
 /** 「1 又は 2」の接続詞は数どうしをつなぐが、続き番号の注の本文は「31 ただし、…」のように接続詞でも始まる。 */
 const CONJUNCTIONS = new Set(["CCONJ", "SCONJ"]);
@@ -221,6 +229,7 @@ export type NameContext = {
 export const isNumberName = (text: string, run: Span, tokens: readonly Token[] | undefined, base: number, context: NameContext = {}): boolean => {
   const inSequence = context.sequence?.has(base + run.start) ?? false;
   if (tokens === undefined) return false;
+  if (PLAIN_CODE.test(text.slice(run.start, run.end))) return !isCounterOrNumber(wordAfter(tokens, text, run, base));
   const shaped =
     inSequence ||
     isNameShaped(text, run) ||

package/src/profile/cue-lines.ts

@@ -0,0 +1,14 @@
+/**
+ * 行頭の箇条の印。Markdown の印（- * + と 1. 1)）は後ろに空白が要る。「・」は日本語で手で打つ箇条の印で、空白を置かずに続けて書く。
+ * 「**賃料**」の太字や「-5」は印ではない。
+ */
+const LIST_MARKER = /^([ \t]*)(?:(?:[-*+]|\d{1,9}[.)])[ \t]+|・[ \t\u3000]*)/gmu;
+
+/** 行頭で項目の名だけを包む太字（「**賃料**：」）。名の後ろにすぐ区切りが来るときだけで、文の中の太字は外さない。 */
+const BOLD_LABEL = /^([ \t]*)\*\*([^*:：|｜\n]+)\*\*(?=[ \t]*[|｜:：])/gmu;
+
+/**
+ * 内容から種類を選ぶ行を読むために、行頭の箇条の印と、項目の名を包む太字を外す。字下げは残す。
+ * 「- 賃料：85,000円」「・賃料：85,000円」「**賃料**：85,000円」も「賃料：85,000円」と同じ項目の行として数えるため。
+ */
+export const withoutListMarkers = (source: string): string => source.replace(LIST_MARKER, "$1").replace(BOLD_LABEL, "$1$2");

package/src/profile/parse.ts

@@ -1,4 +1,5 @@
 import type { DocumentProfile, RelativeVocabulary } from "../plugin.ts";
+import { withoutListMarkers } from "./cue-lines.ts";
 
 /** profiles/*.yaml を一つ読んだもの。言語ごとの中身と、内容から選ぶための形を持つ。 */
 export type ProfileDefinition = {
@@ -137,10 +138,10 @@ export const parseProfile = (raw: unknown): ProfileDefinition | undefined => {
   return { id, name: texts(raw["name"]), detect, languages: languagesOf(id, raw) };
 };
 
-/** 行頭から数える。source 全体に m フラグで当てれば、行ごとに分けずに数えられる。 */
+/** 行頭から数える。source 全体に m フラグで当てれば、行ごとに分けずに数えられる。箇条の印は行頭に数えない。 */
 export const detected = (definition: ProfileDefinition, source: string, language: string): boolean => {
   const detect = definition.detect[language];
   if (detect === undefined) return false;
-  const count = [...source.matchAll(new RegExp(detect.line, "gmu"))].length;
+  const count = [...withoutListMarkers(source).matchAll(new RegExp(detect.line, "gmu"))].length;
   return count >= detect.minLines;
 };

package/src/reference-numbers.ts

@@ -18,7 +18,7 @@ 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 LABEL_TO_NUMBER = /^[\s:：,，、#＃(（「『[［]{0,4}$/u;
 
 export const charactersOf = (written: string): string => written.normalize("NFKC").replaceAll(SEPARATOR, "").replaceAll(" ", "").toUpperCase();
 

package/src/sentence-load.ts

@@ -20,18 +20,23 @@ const BRACKETS: Readonly<Record<string, string>> = {
   "“": "”",
 };
 
+/** A closer and the same closer in the other width: a numbering marker written (1） closes the bracket it opened. */
+const OTHER_WIDTH: Readonly<Record<string, string>> = { ")": "）", "）": ")", "]": "］", "］": "]" };
+
 /** A formula written in TeX ($d^k = -\nabla f(x^k)$): its brackets are the formula's, not the sentence's. */
 const FORMULA = /\$\$[^$]*\$\$|\$[^$\n]*\$/gu;
 
 /**
  * The deepest the brackets of a text nest: 「計画（案）」 is one, 「（注（a）を参照）」 two, plain text none. A closer with no
- * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, and formulas in $…$ are skipped.
+ * opener (the 1) of a list) is ignored, an opener never closed counts as open until the end, a closer of the other width closes
+ * its opener ((1） is one), and formulas in $…$ are skipped.
  */
 export const bracketDepth = (text: string): number => {
   // The closers still awaited, innermost last. Pushed and popped in place: copying it per character is quadratic on deep nesting.
   const awaited: string[] = [];
   return [...text.replace(FORMULA, " ")].reduce((deepest, char) => {
-    if (awaited.at(-1) === char) awaited.pop();
+    const innermost = awaited.at(-1);
+    if (innermost !== undefined && (innermost === char || innermost === OTHER_WIDTH[char])) awaited.pop();
     else if (BRACKETS[char] !== undefined) awaited.push(BRACKETS[char]);
     return Math.max(deepest, awaited.length);
   }, 0);

package/src/spaced-person-name.ts

@@ -4,7 +4,7 @@ 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[] };
@@ -31,6 +31,13 @@ const LINE_MARKS = /^[\s>*#+-]*/u;
 const FIELD_END = /^[\u0020\u3000]*(?:[（(][^（()）\n]*[）)][\u0020\u3000]*)?(?:\r?\n|$)/u;
 
 const isHan = (letter: string | undefined): boolean => letter !== undefined && HAN.test(letter);
+const KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}]$/u;
+const LEADING_KANA = /^[\p{Script=Hiragana}\p{Script=Katakana}ー]+/u;
+/** かなで書いた名の字数（あかり、エミリー）。一字のかな（ご担当 の ご）は名でない。 */
+const MIN_KANA_GIVEN = 2;
+const MAX_KANA_GIVEN = 5;
+
+const isKana = (letter: string | undefined): boolean => letter !== undefined && KANA.test(letter);
 
 /** 人を書く欄の行（承認者：営業部長 高瀬 誠）で、姓が欄の語の後ろにあるか。 */
 const isInPersonField = (source: string, surnameStart: number, labels: readonly string[]): boolean => {
@@ -53,8 +60,23 @@ const givenBeforeSuffix = (run: string, after: string, words: readonly string[])
     });
 };
 
+/**
+ * かなで書いた名（松本 あかり 様）。かなの連なりまるごとを名と読み、後ろに空白一つまでを挟んで敬称か肩書きが付くか、人を書く欄の
+ * 行の終わりにあるときだけ。かなの続きの中で敬称を切り出さない（みなさま を みな と さま にしない）。
+ */
+const kanaGivenAt = (source: string, start: number, cues: SpacedNameCues, inField: boolean, fieldGivens: ReadonlySet<string>): string | undefined => {
+  const run = LEADING_KANA.exec(source.slice(start, start + LOOKBACK))?.[0];
+  const length = [...(run ?? "")].length;
+  if (run === undefined || length < MIN_KANA_GIVEN || length > MAX_KANA_GIVEN) return undefined;
+  const after = source.slice(start + run.length, start + run.length + LOOKBACK);
+  const rest = after.replace(ONE_SPACE, "");
+  if ([...cues.suffixes, ...cues.titles].some((word) => rest.startsWith(word))) return run;
+  return fieldGivens.has(run) || (inField && FIELD_END.test(after)) ? run : undefined;
+};
+
 /** fieldGivens は、文書が人を書く欄に書いた名（亮）。その名と同じ漢字の連なりは、敬称が無くても名と読む。 */
 const givenAt = (source: string, start: number, cues: SpacedNameCues, inField: boolean, fieldGivens: ReadonlySet<string>): string | undefined => {
+  if (isKana(source.charAt(start))) return kanaGivenAt(source, start, cues, inField, fieldGivens);
   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);
@@ -73,10 +95,13 @@ const surnameBefore = (source: string, space: number, cues: SpacedNameCues): str
   return [...cues.titles, ...cues.suffixes].some((word) => run.endsWith(word)) ? undefined : run;
 };
 
+/** 名の頭の字。漢字か、かな（松本 あかり）。 */
+const isNameLetter = (letter: string | undefined): boolean => isHan(letter) || isKana(letter);
+
 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]))
+    if (!isHan(LAST_LETTER.exec(source.slice(Math.max(0, space - 2), space))?.[0]) || !isNameLetter(FIRST_LETTER.exec(source.slice(space + 1, space + 3))?.[0]))
       return [];
     const surname = surnameBefore(source, space, cues);
     if (surname === undefined) return [];

package/src/spacing-code.ts

@@ -28,6 +28,15 @@ const HYPHENATED = new RegExp(
   "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");
+/**
+ * A Japanese number plate after its place name: a class number of two or three digits, one hiragana and a serial
+ * (330 ね 48-15, 500み・・12). A one-digit class number, or a serial that a kanji or katakana word follows, is a reference
+ * such as 「表3の12-15行」「表30の12-34行」, not a plate. The spaces inside a plate are its layout, and the one before it ends the place name.
+ */
+const PLATE = new RegExp(
+  `(?<![\\d${HYPHEN_CHARS}])\\d{2,3}[ \\u3000]?\\p{Script=Hiragana}[ \\u3000]?(?:\\d{1,2}[${HYPHEN_CHARS}]\\d{2}|[・･]{1,3}\\d{1,3})(?![\\d${HYPHEN_CHARS}\\p{Script=Han}\\p{Script=Katakana}])`,
+  "gu",
+);
 const HAS_LETTER = /[A-Za-z]/u;
 const SERIAL_DIGITS = /\d{3}/u;
 
@@ -40,8 +49,10 @@ export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).f
 
 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)));
+export const identifierSpans = (text: string): Span[] => [
+  ...[...spansOf(text, HYPHENATED), ...spansOf(text, CAPITALS_SERIAL)].filter((span) => isIdentifier(text.slice(span.start, span.end))),
+  ...spansOf(text, PLATE),
+];
 
 /** 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/spacing-minority.ts

@@ -25,3 +25,20 @@ export const minorityReport = <T extends { readonly spaced: boolean }>(ofKind: r
   const spaced = ofKind.filter((entry) => entry.spaced).length;
   return { mode: "mixed", first, odd: odd.length, spaced, touching: ofKind.length - spaced };
 };
+
+/** 同数のとき、書き方が二通りあると 1 件で言う最少の数。1 対 1 は一つずつの書き違いとも区別がつかないので言わない。 */
+const MIN_TIE = 2;
+
+/**
+ * 二通りが同じ数なら少ないほうは無く、1 箇所ずつ「違う」と指すとどちらかの側に立つ。MIN_TIE 対 MIN_TIE 以上なら書き方が二通りあることを 1 件で言い、
+ * それより少なければ言わない。同数でなければ report のまま。
+ */
+export const withoutSideOnTie = <T extends { readonly spaced: boolean }>(
+  report: MinorityReport<T> | undefined,
+  ofKind: readonly T[],
+): MinorityReport<T> | undefined => {
+  if (report?.mode !== "each" || report.odd.length * 2 !== ofKind.length) return report;
+  const first = ofKind[0];
+  if (report.odd.length < MIN_TIE || first === undefined) return undefined;
+  return { mode: "mixed", first, odd: report.odd.length, spaced: report.odd.length, touching: report.odd.length };
+};

package/src/structure/cited-document-section.ts

@@ -0,0 +1,42 @@
+import type { StructureNode } from "../plugin.ts";
+
+// 他の文書を引き写した節。「##### 地方公務員法」の下に引いた第十六条の「第六十条」は、地方公務員法の条で、この文書の条ではない。
+
+/** heading: いちばん近い見出しの節の言葉。inArticle: 条の中か。 */
+type Visit = { readonly node: StructureNode; readonly heading: string | undefined; readonly inArticle: boolean };
+
+/** 見出しの言葉。文書の最初の見出しは文書自身の題（「# 就業規則」）なので、他の文書の名前として読まない。 */
+const headingOf = (node: StructureNode, title: StructureNode | undefined): string | undefined =>
+  node === title ? undefined : String(node.attrs["heading"] ?? "").trim();
+
+const documentsCited = (nodes: readonly StructureNode[]): ReadonlySet<string> =>
+  new Set(nodes.flatMap((node) => (node.kind === "reference" && typeof node.attrs["document"] === "string" ? [node.attrs["document"]] : [])));
+
+/** 木を上から順に、見出しの言葉と条の中かと一緒に並べる。再帰にしないのは、深い木でスタックを使い切らないため。 */
+const visitsOf = (tree: StructureNode): Visit[] => {
+  const title = tree.children.find((child) => child.kind === "section");
+  const visits: Visit[] = [];
+  const pending: Visit[] = [{ node: tree, heading: undefined, inArticle: false }];
+  while (pending.length > 0) {
+    const visit = pending.pop();
+    if (visit === undefined) break;
+    visits.push(visit);
+    const { node } = visit;
+    const heading = node.kind === "section" ? headingOf(node, title) : visit.heading;
+    const inArticle = node.kind === "section" ? false : visit.inArticle || node.kind === "article";
+    node.children.toReversed().forEach((child) => pending.push({ node: child, heading, inArticle }));
+  }
+  return visits;
+};
+
+/**
+ * 見出しが他の文書の名前そのものである節に引き写した条の中の参照。その名前を文書がほかで他の文書として引いている
+ * （「地方公務員法第16条」）ときだけ、節はその文書を引き写したものと読む。条の外の地の文の参照は、この文書のもの。Pure.
+ */
+export const referencesInCitedDocuments = (tree: StructureNode): ReadonlySet<StructureNode> => {
+  const visits = visitsOf(tree);
+  const cited = documentsCited(visits.map((visit) => visit.node));
+  if (cited.size === 0) return new Set();
+  const quoted = visits.filter((visit) => visit.node.kind === "reference" && visit.inArticle && visit.heading !== undefined && cited.has(visit.heading));
+  return new Set(quoted.map((visit) => visit.node));
+};