chaffjs 0.35.0 → 0.37.0

package/src/literal-quote.ts

@@ -0,0 +1,55 @@
+// A quotation that holds a string to be typed as it stands: an e-mail subject (件名に「応募（総務課）」と記載), a file name
+// (「【様式】（氏名）」とファイル名を変更), a title (titled “Rates (2026)”). Its brackets are the string's own; the writer cannot
+// take them out. Which words around a quotation say so come from the language's literal-quote-cue lexicon. Pure.
+import { QUOTATION_MARKS, quotedSpans } from "./quoted-span.ts";
+import type { LexiconEntry, Span } from "./plugin.ts";
+
+export type LiteralCues = { readonly before: readonly string[]; readonly after: readonly string[] };
+
+/** The cues of the lexicon: `position: before` stands in front of the quotation (件名に「…」), the rest right after it (「…」と記載). */
+export const literalCues = (entries: readonly LexiconEntry[]): LiteralCues => ({
+  before: entries.filter((entry) => entry.position === "before").map((entry) => entry.pattern.toLowerCase()),
+  after: entries.filter((entry) => entry.position !== "before").map((entry) => entry.pattern.toLowerCase()),
+});
+
+/** Spaces allowed between a cue and its quotation; farther than this the cue is not the quotation's. */
+const GAP = 8;
+const LATIN_LETTER = /[A-Za-z]/u;
+
+/** A cue that begins or ends with a Latin letter is a word: named does not match the end of unnamed. */
+const standsBefore = (window: string, cue: string): boolean =>
+  window.endsWith(cue) && !(LATIN_LETTER.test(cue.at(0) ?? "") && LATIN_LETTER.test(window.at(-cue.length - 1) ?? ""));
+
+const standsAfter = (window: string, cue: string): boolean =>
+  window.startsWith(cue) && !(LATIN_LETTER.test(cue.at(-1) ?? "") && LATIN_LETTER.test(window.at(cue.length) ?? ""));
+
+/** How far from a quotation to read: the longest cue, one letter more to tell a word from part of one, and the gap. */
+const reachOf = (cues: LiteralCues): number => Math.max(0, ...[...cues.before, ...cues.after].map((cue) => cue.length)) + 1 + GAP;
+
+/** Only the few characters next to the quotation are read, so a sentence of many quotations stays linear. */
+const isLiteral = (text: string, quoted: Span, cues: LiteralCues, reach: number): boolean => {
+  const opener = quoted.start - 1;
+  const closerEnd = quoted.end + 1;
+  const before = text
+    .slice(Math.max(0, opener - reach), opener)
+    .trimEnd()
+    .toLowerCase();
+  const after = text
+    .slice(closerEnd, closerEnd + reach)
+    .trimStart()
+    .toLowerCase();
+  return cues.before.some((cue) => standsBefore(before, cue)) || cues.after.some((cue) => standsAfter(after, cue));
+};
+
+/** The insides of the quotations the cues mark as a literal string, without the quotation marks. Positions count from 0 in `text`. */
+export const literalQuoteSpans = (text: string, cues: LiteralCues): Span[] => {
+  const reach = reachOf(cues);
+  return quotedSpans(text, QUOTATION_MARKS).filter((quoted) => isLiteral(text, quoted, cues, reach));
+};
+
+/** The text with each literal quotation's inside blanked to spaces, so a measure of the sentence's own brackets skips it. */
+export const withoutLiteralQuotes = (text: string, cues: LiteralCues): string => {
+  const units = text.split("");
+  literalQuoteSpans(text, cues).forEach((span) => units.fill(" ", span.start, span.end));
+  return units.join("");
+};

package/src/nado-closed-list.ts

@@ -38,6 +38,8 @@ const CLAUSE_POS: ReadonlySet<string> = new Set(["AUX", "VERB"]);
 /** A verb form that modifies a noun inside a list (a driving licence, used cars). */
 const NOUN_MODIFYING_FORMS: ReadonlySet<string> = new Set(["Ger", "Part"]);
 const LIST_SEPARATOR = /[,、]/u;
+/** The parts of speech a list item is made of. */
+const NAME_POS: ReadonlySet<string> = new Set(["NOUN", "PROPN"]);
 
 /** Where a word occurs in a text; a Latin word only as whole words, any case. */
 const placesOf = (text: string, word: string): number[] => {
@@ -59,12 +61,53 @@ const standsAsOpenWord = (tokens: readonly Token[], at: number, open: string): b
   return token !== undefined && open.toLowerCase().startsWith(token.surface.toLowerCase()) && token.features?.NounType !== CLASS_NOUN;
 };
 
-const limitRightAfter = (rest: string, words: ClosedListWords): string | undefined => {
-  const after = rest.slice(BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0].length ?? 0);
-  if (words.notLimits.some((phrase) => startsWithWord(after, phrase))) return undefined;
+const BRACKET = /[(（)）]/gu;
+const CLOSE_BRACKET = /[)）]/u;
+
+/** Where the bracket still open at offset opened, or -1 when none is. */
+const openBracketBefore = (text: string, at: number): number => {
+  const stillOpen = [...text.slice(0, at).matchAll(BRACKET)].reduce<number[]>(
+    (open, bracket) => (CLOSE_BRACKET.test(bracket[0]) ? open.slice(0, -1) : [...open, bracket.index]),
+    [],
+  );
+  return stillOpen.at(-1) ?? -1;
+};
+
+/**
+ * The open word ends an aside on the word before the bracket, and the limit stands outside it (従業員（エンジニア、デザイナー等）のみ):
+ * the limit governs that word, and the list only gives examples of it.
+ */
+const closesAsideBeforeLimit = (text: string, at: number, skipped: string): boolean => {
+  if (!CLOSE_BRACKET.test(skipped)) return false;
+  const bracket = openBracketBefore(text, at);
+  return LETTER.test(text.slice(0, Math.max(bracket, 0)).trimEnd().at(-1) ?? "");
+};
+
+const limitRightAfter = (text: string, at: number, open: string, words: ClosedListWords): string | undefined => {
+  const rest = text.slice(at + open.length);
+  const skipped = BETWEEN_OPEN_AND_LIMIT.exec(rest)?.[0] ?? "";
+  const after = rest.slice(skipped.length);
+  if (words.notLimits.some((phrase) => startsWithWord(after, phrase)) || closesAsideBeforeLimit(text, at, skipped)) return undefined;
   return longestFirst(words.limitsAfter).find((limit) => startsWithWord(after, limit));
 };
 
+const isItemToken = (token: Token | undefined): token is Token => token !== undefined && NAME_POS.has(token.pos);
+
+/** Where the run of nouns written right before end starts (監査 in 監査指示 before 等), or end when no noun ends there. */
+const itemStart = (tokens: readonly Token[], end: number): number => {
+  const last = tokens.find((token) => token.span.end === end);
+  return isItemToken(last) ? itemStart(tokens, last.span.start) : end;
+};
+
+/** The nouns written right before the open word (指示 in 指示等), by the tokens; empty when none are. */
+const itemBefore = (text: string, tokens: readonly Token[], at: number): string => text.slice(itemStart(tokens, at), at);
+
+/** The same list written earlier in the sentence (個別の指示等が … 当該指示等に限り): the open word refers back to it, and leaves nothing new open. */
+const repeatsEarlierList = (text: string, tokens: readonly Token[], at: number, open: string): boolean => {
+  const item = itemBefore(text, tokens, at);
+  return item !== "" && placesOf(text.slice(0, at - item.length), open).some((earlier) => itemBefore(text, tokens, earlier) === item);
+};
+
 const longestFirst = (words: readonly string[]): string[] => [...words].sort((a, b) => b.length - a.length);
 
 const insideNotLimit = (text: string, at: number, notLimits: readonly string[]): boolean =>
@@ -97,9 +140,9 @@ const limitBefore = (text: string, tokens: readonly Token[], at: number, words:
 export const openWordsOnClosedLists = (text: string, tokens: readonly Token[], words: ClosedListWords): OpenOnClosed[] =>
   words.open
     .flatMap((open) => placesOf(text, open).map((at) => ({ open, at })))
-    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open))
+    .filter(({ open, at }) => standsAsOpenWord(tokens, at, open) && !repeatsEarlierList(text, tokens, at, open))
     .flatMap(({ open, at }) => {
-      const limit = limitRightAfter(text.slice(at + open.length), words) ?? limitBefore(text, tokens, at, words);
+      const limit = limitRightAfter(text, at, open, words) ?? limitBefore(text, tokens, at, words);
       return limit === undefined ? [] : [{ offset: at, open, limit }];
     })
     .sort((a, b) => a.offset - b.offset || b.open.length - a.open.length)

package/src/name-misspelt-usual.ts

@@ -0,0 +1,25 @@
+// name-variant points at the less frequent form and names the more frequent one as the usual. When the usual form holds a
+// word the dictionary lacks, one letter from the dictionary word the pointed form has in its place ("Release Sechedule" ×3
+// beside "Release Schedule"), the frequent form is a repeated typo, and the pointed form is the right spelling. Pure.
+import { editsOf } from "./spelling.ts";
+
+/** Whether a lower-case word is a dictionary word, with its endings (lords, schedules). */
+export type IsKnown = (word: string) => boolean;
+
+/** A word the edits are made on: ASCII letters only, as editsOf makes them. */
+const PLAIN_WORD = /^[a-z]+$/u;
+
+const wordsOf = (name: string): string[] => name.toLowerCase().trim().split(/\s+/u);
+
+/** The usual form's word is a one-letter slip of the pointed form's dictionary word in the same place. */
+const isSlipOf = (usualWord: string, nameWord: string, isKnown: IsKnown): boolean =>
+  PLAIN_WORD.test(usualWord) && PLAIN_WORD.test(nameWord) && isKnown(nameWord) && !isKnown(usualWord) && editsOf(usualWord).includes(nameWord);
+
+/** Whether the two forms have the same words in the same places but where the usual one has a one-letter slip of a dictionary word. */
+export const usualIsMisspelt = (name: string, usual: string, isKnown: IsKnown): boolean => {
+  const nameWords = wordsOf(name);
+  const usualWords = wordsOf(usual);
+  if (nameWords.length !== usualWords.length) return false;
+  const differing = usualWords.flatMap((word, index) => (word === nameWords[index] ? [] : [index]));
+  return differing.length > 0 && differing.every((index) => isSlipOf(usualWords[index] ?? "", nameWords[index] ?? "", isKnown));
+};

package/src/name-separator.ts

@@ -63,6 +63,29 @@ const PAIR_LEAD = /^[ \t\u3000]*(?:(?:[-*+]|\d{1,3}[.．)）])[ \t\u3000]+)?/u;
 const PAIR_LABEL = /^[^\s\d、，,（）()｜|：:。！？]{2,12}$/u;
 const PAIR_VALUE = /^\d(?:[^\s、，,（）()｜|。！？]|(?<=\d),(?=\d))*$/u;
 
+/**
+ * 値の後ろに括弧で添えた説明（10万円 (税込 11万円)）の、開く字と閉じる字。囲みは閉じ括弧の手前で終わるので、最後の開き括弧から後ろが説明。
+ * 入れ子の括弧（(税込 (内訳))）は読まない。
+ */
+const ASIDE_PAIRS: ReadonlyMap<string, string> = new Map([
+  ["(", ")"],
+  ["（", "）"],
+]);
+
+/** 説明の括弧の後ろに残ってよいもの: 空白と強調の印。語が続けば（で募集します）文の中の値。 */
+const LINE_REST = /^[\s*_]*$/u;
+
+/**
+ * 組の値。値の後ろに同じ形の括弧で閉じた説明を添えて行が終わるなら、説明を除いた値。閉じていないか、
+ * 説明の後ろに語が続けば undefined。fromEnclosureEnd は囲みの終わり（閉じ括弧か行末）から行末まで。
+ */
+const valueOf = (written: string, fromEnclosureEnd: string): string | undefined => {
+  const aside = Math.max(...[...ASIDE_PAIRS.keys()].map((open) => written.lastIndexOf(open)));
+  if (aside < 0) return written;
+  const closed = fromEnclosureEnd[0] === ASIDE_PAIRS.get(written[aside] ?? "");
+  return closed && LINE_REST.test(fromEnclosureEnd.slice(1)) ? written.slice(0, aside).trimEnd() : undefined;
+};
+
 /** 項目名に出る品詞。名詞だけで、助詞・副詞（およそ）・接頭の語（約）を含めば、量の前置きか文。 */
 const PAIR_LABEL_POS = new Set(["NOUN", "PROPN"]);
 
@@ -92,10 +115,12 @@ const pairAround = (text: string, enclosure: Span, at: number): Span => {
  * 項目名が 1 字（約 30名）か名詞でない語を含む組は、文の中の空白として数える。
  */
 const isLabelledValue = (text: string, boundary: Boundary, tokens: readonly Token[], base: number): boolean => {
-  const enclosure = enclosureAround(text, lineAround(text, boundary.offset), boundary.offset);
+  const line = lineAround(text, boundary.offset);
+  const enclosure = enclosureAround(text, line, boundary.offset);
   const pair = pairAround(text, enclosure, boundary.offset);
   const label = { start: pair.start, end: boundary.offset };
-  if (!PAIR_LABEL.test(text.slice(label.start, label.end)) || !PAIR_VALUE.test(text.slice(boundary.offset + 1, pair.end))) return false;
+  const value = valueOf(text.slice(boundary.offset + 1, pair.end), text.slice(enclosure.end, line.end));
+  if (!PAIR_LABEL.test(text.slice(label.start, label.end)) || value === undefined || !PAIR_VALUE.test(value)) return false;
   if (SENTENCE_END.test(text.slice(enclosure.start, enclosure.end))) return false;
   const labelTokens = tokensIn(tokens, label, base);
   return (

package/src/nominal-stem.ts

@@ -1,4 +1,5 @@
 import type { Token } from "./plugin.ts";
+import { kanjiSkeleton } from "./kana-spelling.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>> = { う: "い", く: "き", ぐ: "ぎ", す: "し", つ: "ち", ぬ: "に", ぶ: "び", む: "み", る: "り" };
@@ -17,20 +18,76 @@ export const isStemForm = (surface: string, lemma: string): boolean => {
 /** 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(["、", "，", ","]);
+/** The verbs that make a verb of a noun written right before them (申出する, 申出できる): the stem form there is the noun. */
+const LIGHT_VERBS = new Set(["する", "できる", "出来る"]);
+
+const carriesTheVerb = (next: Token): boolean => VERB_GOES_ON.has(next.pos) && !(next.pos === "VERB" && LIGHT_VERBS.has(next.lemma ?? ""));
+
+/** A word's kanji and reading, one key for 申出 and 申し出 (申出|モウシデ); undefined for a word with no kanji or no reading. */
+export const nounKeyOf = (token: Token): string | undefined => {
+  const kanji = kanjiSkeleton(token.surface);
+  return kanji === "" || token.reading === undefined ? undefined : `${kanji}|${token.reading}`;
+};
+
+const isAmong = (token: Token, nouns: ReadonlySet<string>): boolean => {
+  const key = nounKeyOf(token);
+  return key !== undefined && nouns.has(key);
+};
 
 /**
  * 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.
+ * (払込み等), a noun the caller lists as one (受取り前), or any noun after a word the document writes as a noun elsewhere
+ * (申し出期限 beside 申出の撤回) 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));
+const verbGoesOn = (token: Token, next: Token, suffixes: ReadonlySet<string>, nouns: ReadonlySet<string>): boolean =>
+  carriesTheVerb(next) ||
+  CLAUSE_COMMA.has(next.surface) ||
+  (next.pos === "NOUN" && next.features?.["Bound"] !== "Yes" && !suffixes.has(next.surface) && !isAmong(token, nouns));
 
 /**
  * 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.
+ * nouns holds the document's nouns (documentNounKeys).
  */
-export const asNounWhereNominal = (token: Token, next: Token | undefined, suffixes: ReadonlySet<string> = new Set()): Token => {
+export const asNounWhereNominal = (
+  token: Token,
+  next: Token | undefined,
+  suffixes: ReadonlySet<string> = new Set(),
+  nouns: 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 };
+  return next !== undefined && verbGoesOn(token, next, suffixes, nouns) ? token : { ...token, pos: "NOUN", lemma: token.surface };
 };
+
+/** A particle that ties what is before it to a noun after it (の, での, に関する, における): what follows it is a noun. */
+const ATTRIBUTIVE_PARTICLE = /[のる]$/u;
+
+const isStemAfterParticle = (token: Token, previous: Token | undefined, next: Token | undefined): boolean =>
+  previous?.pos === "ADP" &&
+  ATTRIBUTIVE_PARTICLE.test(previous.surface) &&
+  CLAUSE_COMMA.has(next?.surface ?? "") &&
+  token.pos === "VERB" &&
+  token.lemma !== undefined &&
+  isStemForm(token.surface, token.lemma);
+
+/**
+ * The sentence with a stem form between a particle that ties it to a noun and a comma (地域の取組み、) read as the noun it is,
+ * spelled as written: before a comma the stem form is otherwise the verb (課題に取り組み、成果を上げた).
+ */
+export const withNounsAfterParticles = (tokens: readonly Token[]): readonly Token[] =>
+  tokens.map((token, at) => (isStemAfterParticle(token, tokens[at - 1], tokens[at + 1]) ? { ...token, pos: "NOUN", lemma: token.surface } : token));
+
+/**
+ * The keys (nounKeyOf) of the nouns a document writes, stem forms the verb does not go on from included (申出 before の): what
+ * tells asNounWhereNominal that a stem form before a noun makes a compound (申し出期限) rather than ends a clause (疾病にかかり療養).
+ */
+export const documentNounKeys = (sentences: readonly (readonly Token[])[], suffixes: ReadonlySet<string> = new Set()): Set<string> =>
+  new Set(
+    sentences.map(withNounsAfterParticles).flatMap((tokens) =>
+      tokens.flatMap((token, at) => {
+        const key = asNounWhereNominal(token, tokens[at + 1], suffixes).pos === "NOUN" ? nounKeyOf(token) : undefined;
+        return key === undefined ? [] : [key];
+      }),
+    ),
+  );

package/src/notice-header.ts

@@ -0,0 +1,57 @@
+// An official notice's head (通達: 課資2－7 / 各国税局長 殿): a document number and an addressee with an honorific of
+// office. Pure. The words come from the language's notice-header lexicon; a notice takes no greeting and no closing.
+import type { Lexicon } from "./plugin.ts";
+
+/** The words of a notice's head, by their group in the notice-header lexicon. */
+export type NoticeWords = {
+  /** What a document number starts with (課資2－7: 課). */
+  readonly numberPrefixes: readonly string[];
+  /** The word before and the word after the number of a document number written 〜第123号. */
+  readonly numberHeads: readonly string[];
+  readonly numberTails: readonly string[];
+  /** The honorific an official notice puts after its addressee (各国税局長 殿). */
+  readonly addressees: readonly string[];
+};
+
+const patternsIn = (lexicon: Lexicon, group: string): string[] => lexicon.filter((entry) => entry.group === group).map((entry) => entry.pattern);
+
+export const noticeWordsOf = (lexicon: Lexicon): NoticeWords => ({
+  numberPrefixes: patternsIn(lexicon, "number-prefix"),
+  numberHeads: patternsIn(lexicon, "number-head"),
+  numberTails: patternsIn(lexicon, "number-tail"),
+  addressees: patternsIn(lexicon, "addressee"),
+});
+
+/** A document number is one short token of a line: 課資2－7, 総務省発第123号. */
+const MAX_NUMBER_LENGTH = 20;
+const DIGIT = /\p{Nd}/u;
+const BLANK = /\s/u;
+/** A document number is written in kanji, digits and dashes; hiragana makes the line words (課題は3つ). */
+const HIRAGANA = /\p{Script=Hiragana}/u;
+
+/** What follows the prefix: the office's kanji, then numbers joined by dashes (課資3-7: 資, 3-7). 課題3 has no dash. */
+const PREFIXED_NUMBER_BODY = /^\p{Script=Han}*\p{Nd}+(?:[-－‐−–―]\p{Nd}+)+$/u;
+
+const isNumberedForm = (line: string, words: NoticeWords): boolean =>
+  words.numberPrefixes.some((prefix) => prefix !== "" && line.startsWith(prefix) && PREFIXED_NUMBER_BODY.test(line.slice(prefix.length))) ||
+  words.numberTails.some(
+    (tail) => tail !== "" && line.endsWith(tail) && words.numberHeads.some((head) => head !== "" && line.slice(0, -tail.length).includes(head)),
+  );
+
+const isNumberShaped = (line: string): boolean => line.length <= MAX_NUMBER_LENGTH && DIGIT.test(line) && !BLANK.test(line) && !HIRAGANA.test(line);
+
+/** Whether a line is a document number alone: short, one run of characters with a digit and no hiragana, in one of the lexicon's forms. */
+export const isDocumentNumber = (line: string, words: NoticeWords): boolean => {
+  const trimmed = line.trim();
+  return isNumberShaped(trimmed) && isNumberedForm(trimmed, words);
+};
+
+/** Whether a line is an addressee: a name, then the notice's honorific at the line's end (各国税局長 殿). */
+export const isNoticeAddressee = (line: string, words: NoticeWords): boolean => {
+  const trimmed = line.trim();
+  return words.addressees.some((word) => trimmed.endsWith(word) && trimmed.length > word.length);
+};
+
+/** Whether head lines (before the first sentence) hold both a document number and an addressee of a notice. */
+export const isNoticeHead = (headLines: readonly string[], words: NoticeWords): boolean =>
+  headLines.some((line) => isDocumentNumber(line, words)) && headLines.some((line) => isNoticeAddressee(line, words));

package/src/person-forms.ts

@@ -104,6 +104,21 @@ const usualForm = (forms: readonly string[]): string | undefined => {
   return [...counts.entries()].reduce<[string, number] | undefined>((best, next) => (best === undefined || next[1] > best[1] ? next : best), undefined)?.[0];
 };
 
+/**
+ * Pure: entries without the places of a form that also names something else (本社 is also the head office), unless that
+ * form is the slot's usual one. A document that calls itself 当社 writes 本社 for its head office; one that calls itself
+ * 本社 still has its stray 当社 pointed at.
+ */
+export const withoutOtherSenses = <T extends { readonly mention: PersonMention }>(entries: readonly T[], otherSenses: ReadonlySet<string>): T[] => {
+  const usual = new Map(
+    [...new Set(entries.map((entry) => entry.mention.slot))].map((slot) => [
+      slot,
+      usualForm(entries.filter((entry) => entry.mention.slot === slot).map((entry) => entry.mention.form)),
+    ]),
+  );
+  return entries.filter((entry) => !otherSenses.has(entry.mention.form) || usual.get(entry.mention.slot) === entry.mention.form);
+};
+
 /**
  * Pure: for each slot, the places that use another form than the document's usual one. Entries are in document order.
  * Nothing when the slot has one form, when the usual form has fewer than MIN_USUAL places, or when the other forms pass

package/src/plugin.ts

@@ -24,6 +24,11 @@ export type Sentence = {
    * 長さの rule はこの単位で数え、この言語の上限と比べる。
    */
   readonly embeddedLanguage?: EmbeddedLanguage;
+  /**
+   * 行頭の印で始まる箇条書きの項目を始める文（「①誓約書」「・〜に関する業務」）。adapter が入れる。
+   * core は項目ごとに段落を改める。
+   */
+  readonly listItem?: true;
 };
 
 export type EmbeddedLanguage = { readonly id: string; readonly lengthUnit: LengthUnit };

package/src/preamble-paragraphs.ts

@@ -19,10 +19,20 @@ const isNameField = (paragraph: Paragraph, source: string): boolean => {
   return value !== undefined && value.split(/\s+/u).every(isNameWord);
 };
 
+/** A note the text attaches to one of its words (※1 特定の走行環境条件), opened by a mark of the note-mark lexicon. */
+const isNote = (paragraph: Paragraph, source: string, noteMarks: readonly string[]): boolean => {
+  const text = source.slice(paragraph.span.start, paragraph.span.end).trimStart();
+  return noteMarks.some((mark) => mark !== "" && text.startsWith(mark));
+};
+
 /**
  * 本題の前にあって、読み手が読み通す段落。文が一つも終止符で閉じない段落は数えない。
  * 分類の札（「エネルギー・環境」）、著者と所属の行、「印刷」、テンプレートの指示は文ではなく、読ませる前置きではない。
- * 宛先や差出人の欄（To: Minato Manufacturing Inc.）も、値が名前だけなら数えない。source は段落の範囲を読む文書。
+ * 宛先や差出人の欄（To: Minato Manufacturing Inc.）も、値が名前だけなら数えない。本文の語に付けた注（※1 …）は、
+ * 前置きの段落ではなく注なので数えない。source は段落の範囲を読む文書、noteMarks は語彙表 note-mark の印。
  */
-export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number, source = ""): Paragraph[] =>
-  paragraphs.filter((paragraph) => paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed) && !isNameField(paragraph, source));
+export const preambleParagraphs = (paragraphs: readonly Paragraph[], bodyStart: number, source = "", noteMarks: readonly string[] = []): Paragraph[] =>
+  paragraphs.filter(
+    (paragraph) =>
+      paragraph.span.start < bodyStart && paragraph.sentences.some(isClosed) && !isNameField(paragraph, source) && !isNote(paragraph, source, noteMarks),
+  );

package/src/sentence-load.ts

@@ -1,6 +1,7 @@
 // How much one sentence asks the reader to hold at once: brackets inside brackets, clauses chained one after another, and how
 // far the topic stands from the end where its predicate is. Pure: a sentence's text and tokens come in, numbers go out.
 import type { Token } from "./plugin.ts";
+import { topicClauseEnd } from "./topic-clause.ts";
 
 /**
  * Opening brackets and the mark that closes each. Quotation marks that open and close with the same character are left out, and
@@ -26,15 +27,24 @@ 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;
 
+/**
+ * A doubled parenthesis around text with no parenthesis inside (((居住の用に供したとき等)), （（注））): one mark written with two
+ * characters, as a directive sets an article's caption, not a bracket inside a bracket.
+ */
+const DOUBLED_PAREN = /\(\(([^()（）]*)\)\)|（（([^()（）]*)））/gu;
+
+const singled = (text: string): string =>
+  text.replace(DOUBLED_PAREN, (_whole: string, half?: string, full?: string) => (half === undefined ? `（${full ?? ""}）` : `(${half})`));
+
 /**
  * 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, a closer of the other width closes
- * its opener ((1） is one), and formulas in $…$ are skipped.
+ * its opener ((1） is one), a doubled parenthesis ((題)) 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) => {
+  return [...singled(text.replace(FORMULA, " "))].reduce((deepest, char) => {
     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]);
@@ -71,6 +81,7 @@ const TOPIC_BEFORE = new Set(["NOUN", "PRON", "PROPN"]);
 /**
  * How far the sentence's first topic (会議は, これは) stands from the end of the sentence, where Japanese puts the predicate the
  * topic belongs to, in characters of the words between them (spaces, and a link's address the document hides, are not read).
+ * When the topic gets its own predicate in an earlier clause (topicClauseEnd), the distance is to that clause's end.
  * undefined when the sentence has no topic. The distance is the reader's wait: everything between has to be held before the
  * topic is said to do anything.
  */
@@ -78,5 +89,5 @@ export const topicDistance = (tokens: readonly Token[]): number | undefined => {
   const topic = tokens.findIndex((token, at) => token.surface === "は" && token.pos === "ADP" && TOPIC_BEFORE.has(tokens[at - 1]?.pos ?? ""));
   const last = tokens.findLastIndex((token) => !TRAILING.has(token.pos));
   if (topic === -1 || last <= topic) return undefined;
-  return tokens.slice(topic + 1, last).reduce((sum, token) => sum + [...token.surface.replace(/\s/gu, "")].length, 0);
+  return tokens.slice(topic + 1, topicClauseEnd(tokens, topic, last) ?? last).reduce((sum, token) => sum + [...token.surface.replace(/\s/gu, "")].length, 0);
 };

package/src/spacing-code.ts

@@ -7,6 +7,8 @@ import { HYPHEN_CHARS } from "./orthography.ts";
 
 /** 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;
+/** AM or PM written after a clock time, with a space or without (9:30AM, 9:30 p.m.). */
+const MERIDIEM = /^ ?[AaPp]\.?[Mm]\.?(?![A-Za-z])/u;
 
 /** A run of printable ASCII without brackets: an address ends where Japanese text, a space or a bracket starts (…/faq で). */
 const ASCII_RUN = /[!-'*-~]+/gu;
@@ -43,7 +45,9 @@ 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 }));
 
-export const clockTimeSpans = (text: string): Span[] => spansOf(text, CLOCK_TIME);
+/** Clock times, each with the AM or PM written after it (9:30AM). */
+export const clockTimeSpans = (text: string): Span[] =>
+  spansOf(text, CLOCK_TIME).map((span) => ({ start: span.start, end: span.end + (MERIDIEM.exec(text.slice(span.end))?.[0].length ?? 0) }));
 
 export const addressSpans = (text: string): Span[] => spansOf(text, ASCII_RUN).filter((span) => isAddress(text.slice(span.start, span.end)));
 

package/src/split-noun.ts

@@ -0,0 +1,63 @@
+import type { Sentence, Token } from "./plugin.ts";
+import { kanjiSkeleton } from "./kana-spelling.ts";
+
+const ALL_KANJI = /^[\p{Script=Han}々]+$/u;
+/** A bound noun that is kanji and then kana (込み): the okurigana half of a word the tokenizer cut (申 and 込み). */
+const KANJI_THEN_KANA = /^[\p{Script=Han}々]+[ぁ-ゖ]+$/u;
+
+const isTouching = (head: Token, tail: Token): boolean => head.span.end === tail.span.start;
+
+const isKanjiNoun = (token: Token): boolean => token.pos === "NOUN" && ALL_KANJI.test(token.surface);
+
+/** 申 and 込み: a kanji noun and a bound noun of kanji and kana written onto it. */
+const isCutAtKanji = (head: Token, tail: Token): boolean =>
+  isKanjiNoun(head) && tail.pos === "NOUN" && tail.features?.["Bound"] === "Yes" && KANJI_THEN_KANA.test(tail.surface) && isTouching(head, tail);
+
+/**
+ * 申立 and て, the noun's reading already ending in テ (モウシタテ): its last kana cut off as a particle. て never follows a noun as
+ * a particle; other kana (の after 長野, ナガノ) do, so only て is read back.
+ */
+const isCutBeforeTe = (head: Token, tail: Token): boolean =>
+  isKanjiNoun(head) && tail.surface === "て" && (tail.pos === "ADP" || tail.pos === "SCONJ") && head.reading?.endsWith("テ") === true && isTouching(head, tail);
+
+/** The one reading the document gives a noun of these kanji (申込|モウシコミ for 申込); undefined for none or for two. */
+const readingAmong = (kanji: string, nouns: ReadonlySet<string>): string | undefined => {
+  const readings = [...nouns].filter((key) => key.startsWith(`${kanji}|`)).map((key) => key.slice(kanji.length + 1));
+  return readings.length === 1 ? readings[0] : undefined;
+};
+
+const readingOfJoined = (head: Token, tail: Token, nouns: ReadonlySet<string>): string | undefined => {
+  if (isCutAtKanji(head, tail)) return readingAmong(kanjiSkeleton(head.surface + tail.surface), nouns);
+  return isCutBeforeTe(head, tail) ? head.reading : undefined;
+};
+
+const joinedOf = (head: Token, tail: Token | undefined, nouns: ReadonlySet<string>): Token | undefined => {
+  const reading = tail === undefined ? undefined : readingOfJoined(head, tail, nouns);
+  if (tail === undefined || reading === undefined) return undefined;
+  const surface = head.surface + tail.surface;
+  return { span: { start: head.span.start, end: tail.span.end }, surface, pos: "NOUN", lemma: surface, reading };
+};
+
+const joinedTokens = (tokens: readonly Token[], nouns: ReadonlySet<string>): Token[] =>
+  tokens.reduce<{ readonly out: Token[]; readonly skip: boolean }>(
+    ({ out, skip }, token, at) => {
+      if (skip) return { out, skip: false };
+      const joined = joinedOf(token, tokens[at + 1], nouns);
+      out.push(joined ?? token);
+      return { out, skip: joined !== undefined };
+    },
+    { out: [], skip: false },
+  ).out;
+
+/**
+ * The sentence with a noun the tokenizer cut in two read whole: a kanji noun and a bound noun of kanji and kana written onto it
+ * (申 and 込み at the head of a sentence) are one noun (申込み) when the document writes a noun of the same kanji elsewhere
+ * (申し込み, 申込|モウシコミ in nouns), which gives the reading. With no such noun, or two readings for it, the tokens stay as cut.
+ * A kanji noun read with its last kana and that kana cut off as て (申立 and て) is one noun too (申立て).
+ * nouns holds the document's nouns (documentNounKeys).
+ */
+export const withCutNounsJoined = (sentence: Sentence, nouns: ReadonlySet<string>): Sentence => {
+  const tokens = sentence.tokens ?? [];
+  const joined = joinedTokens(tokens, nouns);
+  return joined.length === tokens.length ? sentence : { ...sentence, tokens: joined };
+};

package/src/structure/attached-parts.ts

@@ -0,0 +1,47 @@
+// Where an instrument attached to the document starts: a title line naming it (Exhibit A to Merger Agreement, Annex 1).
+// What is attached is a separate document (a restated charter, a form of note), so its definitions are its own. Pure.
+import { escapeRegExp } from "../orthography.ts";
+import { isShortTitle, isTitleLine, type TitleNotion } from "../title-line.ts";
+
+/** An instrument's title: any case (EXHIBIT A to the merger agreement), but no `: ; ,` after it, and only blank lines around. */
+export const INSTRUMENT_TITLE: TitleNotion = { sentenceEnd: /[.!?。．？！:;,]$/u, capitalised: false, edge: "blank-line" };
+
+/** Bold around a title (## **SCHEDULE A**) is only how it is shown. */
+const BOLD = /\*\*/gu;
+/** A Markdown heading is a block of its own, so it needs no blank line around it (a closing fence may sit just above). */
+const MARKDOWN_HEADING = /^ {0,3}#{1,6}[ \t]/u;
+
+type Line = { readonly start: number; readonly text: string };
+
+const linesOf = (source: string): Line[] => {
+  const starts = [0, ...[...source.matchAll(/\n/gu)].map((match) => match.index + 1)];
+  return starts.map((start, index) => ({ start, text: source.slice(start, (starts[index + 1] ?? source.length + 1) - 1) }));
+};
+
+const opensInstrument = (source: string, lines: readonly Line[], index: number, title: RegExp): boolean => {
+  const line = lines[index];
+  if (line === undefined) return false;
+  const text = line.text.replace(BOLD, "");
+  const label = title.exec(text);
+  if (label === null) return false;
+  const rest = text.slice(label[0].length);
+  if (MARKDOWN_HEADING.test(text)) return isShortTitle(rest, INSTRUMENT_TITLE);
+  const lineEnd = index === lines.length - 1 ? -1 : line.start + line.text.length;
+  return isTitleLine(source, line.start, lineEnd, rest, INSTRUMENT_TITLE);
+};
+
+/**
+ * The offsets of the lines that open an attached instrument: the line holds a label (Exhibit, Annex), its letter or
+ * number and at most a short title with no full stop, and it is a Markdown heading or has a blank line or the
+ * document's edge on both sides. Bold around the title is ignored.
+ */
+export const attachedPartStarts = (source: string, labels: readonly string[]): number[] => {
+  const words = labels.filter((label) => label !== "").map(escapeRegExp);
+  if (words.length === 0) return [];
+  const title = new RegExp(String.raw`^[ \t]*(?:#{1,6}[ \t]+)?(?:${words.join("|")})[ \t]+[A-Z0-9](?:[A-Z0-9\-]|\.(?=[A-Z0-9]))*(?=[ \t\r]|$)`, "u");
+  const lines = linesOf(source);
+  return lines.flatMap((line, index) => (opensInstrument(source, lines, index, title) ? [line.start] : []));
+};
+
+/** Which part an offset falls in: 0 for the document itself, n for the n-th attached instrument. */
+export const partAt = (starts: readonly number[], offset: number): number => starts.filter((start) => start <= offset).length;