chaffjs 0.35.0 → 0.36.0

package/src/link-title.ts

@@ -0,0 +1,38 @@
+import type { Span } from "./plugin.ts";
+import { linkTextOf } from "./link-text.ts";
+
+/**
+ * 外のページの題名を引いたリンクの文字。行の頭に置いたリンク（- [達成基準 2.4.4: リンクの目的 (コンテキスト内)](https://…)、
+ * 参考: [ロードバランサーにタグを付ける](https://…)）は、行き先のページの題名をそのまま写したもので、書き手が言い換えられない。
+ * リンクの後ろは行の終わりか、コロンに続く説明（[題名](https://…): 説明）だけを許す。
+ * 文の中のリンク（詳しくは[こちら](https://…)をご覧ください）は書き手の言葉で、文書の中や手元のファイルへのリンク（[README](./README.md)）は題名ではない。
+ */
+
+const EXTERNAL = /^<?https?:\/\//iu;
+const TEXT_END = "](";
+/** リンクの前に書いてよいもの: 行頭の空白と箇条書きの印、その後ろにコロンで終わる短い見出し語（参考:、出典：、See also:）。 */
+const BULLET = /^[ \t]*(?:(?:[-*+]|\d{1,3}[.)])[ \t]+)?/u;
+const LABEL = /^(?:[^\n:：。、.,[\]]{1,15}[:：][ \t]*)?$/u;
+/** リンクの後ろに書いてよいもの: 行末までの空白と句読点か、説明を始めるコロン。 */
+const LINE_TAIL = /^(?:[ \t.,;。、]*(?:\n|$)|[ \t]*[:：])/u;
+
+/** リンクの文字の範囲。[文字](行き先) の形で、行き先が外のページのものだけ。位置は source の上。 */
+const externalTextOf = (source: string, link: Span): Span | undefined => {
+  const written = source.slice(link.start, link.end);
+  const text = linkTextOf(written);
+  if (text === undefined) return undefined;
+  const destination = written.slice(1 + text.length + TEXT_END.length);
+  return EXTERNAL.test(destination) ? { start: link.start + 1, end: link.start + 1 + text.length } : undefined;
+};
+
+const headsItsLine = (source: string, link: Span): boolean => {
+  const lineStart = source.lastIndexOf("\n", link.start - 1) + 1;
+  return LABEL.test(source.slice(lineStart, link.start).replace(BULLET, "")) && LINE_TAIL.test(source.slice(link.end));
+};
+
+/** 外のページの題名を引いたリンクの、文字の範囲（角括弧は含まない）。位置は source の上。links は doc.links。 */
+export const externalLinkTitleSpans = (source: string, links: readonly Span[]): Span[] =>
+  links.flatMap((link) => {
+    const text = externalTextOf(source, link);
+    return text !== undefined && headsItsLine(source, link) ? [text] : [];
+  });

package/src/list-item-paragraphs.ts

@@ -0,0 +1,22 @@
+import type { Span } from "./plugin.ts";
+
+/** 段落の中の文。listItem は、行頭の印で始まる箇条書きの項目を始める文（adapter が入れる）。 */
+type ItemSentence = { readonly span: Span; readonly listItem?: true };
+
+/**
+ * 空行を挟まずに行頭の印（①、・、(1)）で項目を並べた段落を、項目ごとの段落に割る。
+ * 項目の後ろに続く印の無い行は、その項目の続き。割らないと、項目の並び全体が文の多すぎる 1 つの段落に読まれる。
+ *
+ * sentences は段落の中の文（並び順）。項目が無ければ paragraph 1 つ。
+ */
+export const listItemParagraphs = (paragraph: Span, sentences: readonly ItemSentence[]): Span[] => {
+  const firsts = sentences.flatMap((sentence, index) => (index === 0 || sentence.listItem === true ? [index] : []));
+  if (firsts.length <= 1) return [paragraph];
+  return firsts.map((first, index) => {
+    const next = firsts[index + 1];
+    return {
+      start: index === 0 ? paragraph.start : (sentences[first]?.span.start ?? paragraph.start),
+      end: next === undefined ? paragraph.end : (sentences[next - 1]?.span.end ?? paragraph.end),
+    };
+  });
+};

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-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/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/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,32 @@
+// 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 { 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" };
+
+const linesOf = (source: string): { readonly start: number; readonly text: string }[] => {
+  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) }));
+};
+
+/**
+ * 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 a blank line or the document's edge is on both sides.
+ */
+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) => {
+    const label = title.exec(line.text);
+    if (label === null) return [];
+    const lineEnd = index === lines.length - 1 ? -1 : line.start + line.text.length;
+    return isTitleLine(source, line.start, lineEnd, line.text.slice(label[0].length), INSTRUMENT_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;

package/src/structure/build.ts

@@ -9,6 +9,7 @@ import { lineNumberAt, linesOf, type Line } from "./lines.ts";
 import { universalNumber } from "./universal.ts";
 import { unnumberedUnit, type OpenUnit } from "./unnumbered.ts";
 import { readsOnHeading } from "./heading-leaves.ts";
+import { unspacedHeadings } from "./unspaced-heading.ts";
 import { onLine, wrappedLine, type WrappedLine } from "./wrapped-tail.ts";
 import { foldPostOrder } from "../tree-walk.ts";
 
@@ -260,10 +261,11 @@ const headingsByLine = (lines: readonly Line[], headings: readonly Heading[]): M
  * 見出しの行から見出しの言葉を取る。コードを覆った後の行から取るので、見出しの中のコードも読まない。
  * ATX（行頭が #）なら印と閉じの # を外す。setext（下線で書く見出し）の末尾の # は言葉なので残す。
  */
-const headingLineText = (text: string): string => {
+const headingLineText = (text: string, atx: boolean): string => {
   const line = text.trim();
   if (!line.startsWith("#")) return headingText(line);
-  return atxHeadingText(line.replace(/^#{1,6}(?=[ \t]|$)/u, "").trim());
+  // A heading that ends on its own line is ATX, and its hashes go even with no space after them (unspaced-heading.ts).
+  return atxHeadingText(line.replace(atx ? /^#{1,6}/u : /^#{1,6}(?=[ \t]|$)/u, "").trim());
 };
 
 const captionPatterns = new WeakMap<DocumentProfile, RegExp | undefined>();
@@ -319,7 +321,7 @@ const withCaption = (state: State, line: Line, numbered: NumberedLine | undefine
 type Around = { readonly next: string | undefined; readonly previous: string | undefined; readonly inTable: boolean };
 
 const readLine = (state: State, patterns: StructurePatterns, line: Line, heading: Heading | undefined, around: Around): void => {
-  const text = heading === undefined ? line.text : headingLineText(line.text);
+  const text = heading === undefined ? line.text : headingLineText(line.text, heading.end <= line.start + line.text.length);
   const openNumbers = state.stack.flatMap((frame) => (frame.numbered === undefined ? [] : [frame.numbered]));
   const context = { open: openNumbers, isHeading: heading !== undefined };
   const found = around.inTable ? undefined : (numberedLine(state, patterns, text, context) ?? codeTitledNumber(state, patterns, text, heading, context));
@@ -361,7 +363,8 @@ export const buildTree = (input: StructureInput, patterns: StructurePatterns): S
   // コードは同じ長さの空白で覆ってから読む。コードブロックの行は空になって飛ばされ、
   // 文中の `第99条` は参照として拾われない。位置は元の文書のまま。
   const lines = linesOf(maskSpans(input.source, outline.opaque));
-  const headings = headingsByLine(lines, outline.headings);
+  const marked = headingsByLine(lines, outline.headings);
+  const headings = input.markdown ? new Map([...marked, ...unspacedHeadings(lines, marked, patterns)]) : marked;
   const attrs = { path: input.path, language: input.language, ...(input.profile === undefined ? {} : { profile: input.profile.id }) };
   const doc = draftOf("doc", "", { text: "", start: 0, number: 1 }, attrs);
   doc.end = input.source.length;

package/src/structure/contents-lines.ts

@@ -0,0 +1,63 @@
+import type { MarkupHeading } from "../plugin.ts";
+import { lineNumberAt, type Line } from "./lines.ts";
+
+// 目次・索引の行と、番号に題だけを続けた行。どれも本文の文ではなく、文書の案内。純関数: 行と Markdown の見出しを受け取る。
+
+/** 項目の終わり（ページ番号、条の番地 2.04(c)）の後ろに、次の項目の大文字が続く所。 */
+const ENTRY_BREAK = /(?<![\p{L}\p{N}$.,])\d+(?:\.\d+)*(?:\([\p{L}\p{N}]{1,4}\))*\s+(?=\p{Lu})/gu;
+/** 一行に詰めた目次・索引と読むのに要る、項目の切れ目の数（Closing 2 Section 1.2 The Merger 2 ARTICLE II）。 */
+const MIN_ENTRY_BREAKS = 3;
+/** 目次・索引の行の言葉は、ほとんどが大文字で始まる。短くない語のうち小文字で始まる語がこの割合以上なら文。 */
+const MAX_LOWERCASE_SHARE = 1 / 3;
+/** これより短い語（of、and、the、番地の (c)、iii）は、題の中でも小文字で書く。 */
+const MIN_CAPITALISED_LENGTH = 4;
+const WORD = /\p{L}[\p{L}'’-]*/gu;
+const LOWERCASE_START = /^\p{Ll}/u;
+
+/** 短くない語のうち、小文字で始まる語の割合。 */
+const lowercaseShare = (text: string): number => {
+  const words = (text.match(WORD) ?? []).filter((word) => word.length >= MIN_CAPITALISED_LENGTH);
+  return words.length === 0 ? 1 : words.filter((word) => LOWERCASE_START.test(word)).length / words.length;
+};
+
+/** 項目と番号を一行に詰めた目次・索引（Section 1.1 Closing 2 Section 1.2 The Merger 2、Company RSU 2.04(b) Company SEC Documents 4.07(a)）。 */
+const isPackedContents = (text: string): boolean => [...text.matchAll(ENTRY_BREAK)].length >= MIN_ENTRY_BREAKS && lowercaseShare(text) < MAX_LOWERCASE_SHARE;
+
+/** 番号に題を続けただけの行（1 Supply of Ingredients）。題の語は大文字で始まり、文の終わりの印を持たない。 */
+const NUMBERED_TITLE = /^\s*\d+(?:\.\d+)*\.?\s+\p{Lu}[^.。:;,!?]*$/u;
+/** 題と読む語の数の上限。 */
+const MAX_TITLE_WORDS = 8;
+
+const NOT_LATIN_LETTER = /[^\P{L}\p{Script=Latin}]/u;
+
+/** 英語の題の言葉か: 語が多すぎず、短くない語がどれも大文字で始まる（Supply of Ingredients、Extension; Waiver）。 */
+export const isTitleWords = (text: string): boolean => {
+  const words = text.match(WORD) ?? [];
+  return (
+    words.length > 0 &&
+    !NOT_LATIN_LETTER.test(text) &&
+    words.length <= MAX_TITLE_WORDS &&
+    words.every((word) => word.length < MIN_CAPITALISED_LENGTH || !LOWERCASE_START.test(word))
+  );
+};
+
+const isNumberedTitle = (text: string): boolean => NUMBERED_TITLE.test(text) && isTitleWords(text);
+
+/** 目次の見出し（語彙表 toc-heading）の下、次の見出しまでの行の番号。 */
+const linesUnderContentsHeading = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): number[] => {
+  const names = new Set(tocWords.map((word) => word.toLowerCase()));
+  return headings.flatMap((heading, index) => {
+    if (!names.has(heading.text.trim().toLowerCase())) return [];
+    const from = lineNumberAt(lines, heading.start) ?? 0;
+    const next = headings[index + 1];
+    const to = next === undefined ? lines.length + 1 : (lineNumberAt(lines, next.start) ?? lines.length + 1);
+    return lines.filter((line) => line.number > from && line.number < to).map((line) => line.number);
+  });
+};
+
+/** 目次・索引の行と、番号に題だけを続けた行の番号（1 始まり）。 */
+export const contentsLineNumbers = (lines: readonly Line[], headings: readonly MarkupHeading[], tocWords: readonly string[]): ReadonlySet<number> =>
+  new Set([
+    ...linesUnderContentsHeading(lines, headings, tocWords),
+    ...lines.filter((line) => isPackedContents(line.text) || isNumberedTitle(line.text)).map((line) => line.number),
+  ]);