hanlint 0.0.2 → 0.0.8

package/src/document/parseMarkdown.js

@@ -4,15 +4,20 @@
  * 빈 줄로 블록을 나누고 첫 줄로 종류를 정한다. 코드 펜스 안은 통째로 code 다. H2 가 절을 열고 첫 H2 앞은 도입 절이다.
  */
 import { splitLines } from "../text.js";
-import { CODE, EMBED, HEADING, HTML, IMAGE, LIST, PROSE, TABLE } from "./model.js";
+import { CODE, EMBED, HEADING, HTML, IMAGE, LIST, PROSE, QUOTE, TABLE } from "./model.js";
 
 const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
-const FENCE = /^\s*(```|~~~)/;
+const FENCE_OPEN = /^\s*(?:(`{3,})([^`]*)|(~{3,})([^~]*))$/;
+const FENCE_CLOSE = /^\s*(`{3,}|~{3,})\s*$/;
 const HEADING_LINE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+const INDENTED_CODE_LINE = /^(?: {4}|\t)/;
+const QUOTE_LINE = /^\s*>/;
 const IMAGE_LINE = /^!\[/;
-const LIST_LINE = /^\s*(?:[-*+]|\d+[.)])\s+/;
+const LIST_LINE = /^(\s*)(?:[-*+]|\d+[.)])\s+/;
 const TABLE_LINE = /^\s*\|/;
 const URL_LINE = /^\s*https?:\/\/\S+\s*$/;
+// 링크 하나만 있는 줄은 끼워 넣은 것 (영상 카드, 실행 칸, 참고 링크) 이라 주소만 있는 줄과 같은 embed 다. 파이썬과 같다.
+const LINK_ONLY_LINE = /^\s*\[[^\]\n]+\]\(\S+?(?:\s+"[^"\n]*")?\)\s*$/;
 const HTML_LINE = /^\s*</;
 const META_KEY = /^[A-Za-z][A-Za-z0-9_]*$/;
 const CONTROL = /^\s*<!--\s*hanlint-(disable-next-line|disable-next|disable|enable)\b([^>]*?)-->\s*$/;
@@ -34,16 +39,40 @@ export function parseFrontmatter(text) {
 }
 
 /** @param {string} firstLine */
-export function classify(firstLine) {
+export function classify(firstLine, lineCount = 1) {
+  if (INDENTED_CODE_LINE.test(firstLine)) return CODE;
   if (HEADING_LINE.test(firstLine)) return HEADING;
+  if (QUOTE_LINE.test(firstLine)) return QUOTE;
   if (IMAGE_LINE.test(firstLine)) return IMAGE;
   if (TABLE_LINE.test(firstLine)) return TABLE;
   if (LIST_LINE.test(firstLine)) return LIST;
-  if (URL_LINE.test(firstLine)) return EMBED;
+  if (URL_LINE.test(firstLine) || (lineCount === 1 && LINK_ONLY_LINE.test(firstLine))) return EMBED;
   if (HTML_LINE.test(firstLine)) return HTML;
   return PROSE;
 }
 
+/** @param {string} line */
+function indentWidth(line) {
+  let width = 0;
+  for (const char of line) {
+    if (char === " ") width += 1;
+    else if (char === "\t") width += 4 - (width % 4);
+    else break;
+  }
+  return width;
+}
+
+/** @param {string} line @param {number} width */
+function afterIndent(line, width) {
+  let index = 0;
+  let consumed = 0;
+  while (index < line.length && consumed < width && (line[index] === " " || line[index] === "\t")) {
+    consumed += line[index] === " " ? 1 : 4 - (consumed % 4);
+    index += 1;
+  }
+  return line.slice(index);
+}
+
 /**
  * @param {string} text
  * @param {number} firstLine
@@ -61,10 +90,18 @@ export function splitBlocks(text, firstLine) {
   let fenceStart = 0;
   /** @type {string[]} */
   let fenceLines = [];
+  /** @type {number | null} */
+  let listContinuation = null;
+  /** @type {number | null} */
+  let bufferListContinuation = null;
 
   const flush = () => {
     if (!buffer.length) return;
-    const kind = classify(buffer[0]);
+    let firstLine = buffer[0];
+    if (bufferListContinuation !== null && indentWidth(firstLine) >= bufferListContinuation) {
+      firstLine = afterIndent(firstLine, bufferListContinuation);
+    }
+    const kind = classify(firstLine, buffer.length);
     let joined = buffer.join("\n");
     let level = 0;
     if (kind === HEADING) {
@@ -74,6 +111,7 @@ export function splitBlocks(text, firstLine) {
     }
     blocks.push({ kind, startLine: bufferStart, endLine: bufferStart + buffer.length - 1, text: joined, level, index: blocks.length });
     buffer = [];
+    bufferListContinuation = null;
   };
 
   for (const raw of splitLines(text)) {
@@ -81,17 +119,18 @@ export function splitBlocks(text, firstLine) {
     const line = raw.replace(/\r+$/, "");
     if (fence) {
       fenceLines.push(line);
-      if (FENCE.test(line) && line.trim().startsWith(fence)) {
+      const closing = FENCE_CLOSE.exec(line);
+      if (closing && closing[1].startsWith(fence) && closing[1][0] === fence[0]) {
         blocks.push({ kind: CODE, startLine: fenceStart, endLine: lineNo, text: fenceLines.join("\n"), level: 0, index: blocks.length });
         fence = null;
         fenceLines = [];
       }
       continue;
     }
-    const opening = FENCE.exec(line);
+    const opening = FENCE_OPEN.exec(line);
     if (opening) {
       flush();
-      fence = opening[1];
+      fence = opening[1] || opening[3];
       fenceStart = lineNo;
       fenceLines = [line];
       continue;
@@ -106,7 +145,17 @@ export function splitBlocks(text, firstLine) {
       continue;
     }
     if (HEADING_LINE.test(line) && buffer.length) flush();
-    if (!buffer.length) bufferStart = lineNo;
+    const listMatch = LIST_LINE.exec(line);
+    if (listMatch) {
+      const contentColumn = listMatch[0].length;
+      listContinuation = Math.ceil(contentColumn / 4) * 4;
+    } else if (listContinuation !== null && indentWidth(line) < listContinuation) {
+      listContinuation = null;
+    }
+    if (!buffer.length) {
+      bufferStart = lineNo;
+      bufferListContinuation = listContinuation;
+    }
     buffer.push(line);
     if (HEADING_LINE.test(line)) flush();
   }
@@ -170,6 +219,30 @@ export function disabledRanges(blocks) {
   return ranges;
 }
 
+/** 코드 블록 첫 줄의 언어 표기 (```python 의 python). 없으면 빈 문자열. 소문자로 준다. @param {string} blockText */
+export function fenceLanguage(blockText) {
+  const opening = FENCE_OPEN.exec(blockText.split("\n", 1)[0]);
+  if (!opening) return "";
+  const info = (opening[2] || opening[4] || "").trim();
+  return info ? info.split(/\s+/)[0].toLowerCase() : "";
+}
+
+/**
+ * 언어 표기가 languages 에 든 펜스를 없앤 문서. 블록 순서 번호를 다시 매기고 절을 다시 묶는다. 인라인 제어는 원문 줄
+ * 기준이라 그대로 두고, 뺀 펜스는 ignored 에 남긴다. 파이썬 dropFences 와 같다.
+ * @param {import("./model.js").Document} doc
+ * @param {string[]} languages
+ * @returns {import("./model.js").Document}
+ */
+export function dropFences(doc, languages) {
+  const wanted = new Set(languages.map((name) => name.trim().toLowerCase()).filter(Boolean));
+  if (!wanted.size) return doc;
+  const dropped = doc.blocks.filter((block) => block.kind === CODE && wanted.has(fenceLanguage(block.text)));
+  if (!dropped.length) return doc;
+  const blocks = doc.blocks.filter((block) => !dropped.includes(block)).map((block, index) => ({ ...block, index }));
+  return { path: doc.path, frontmatter: doc.frontmatter, blocks, sections: groupSections(blocks), disabled: doc.disabled, ignored: [...doc.ignored, ...dropped] };
+}
+
 /**
  * @param {string} text
  * @param {string | null} [path]
@@ -179,5 +252,5 @@ export function parseMarkdown(text, path = null) {
   const { meta, firstLine } = parseFrontmatter(text);
   const body = firstLine === 1 ? text : splitLines(text).slice(firstLine - 1).join("\n");
   const blocks = splitBlocks(body, firstLine);
-  return { path, frontmatter: meta, blocks, sections: groupSections(blocks), disabled: disabledRanges(blocks) };
+  return { path, frontmatter: meta, blocks, sections: groupSections(blocks), disabled: disabledRanges(blocks), ignored: [] };
 }

package/src/fingerprint/build.js

@@ -1,11 +1,16 @@
 // @ts-check
 /** 문서 모델을 한 번 훑어 글 지문을 만든다. 텍스트를 읽는 유일한 자리다. 파이썬 fingerprint/build.py 와 같다. */
 import { defaultConfig } from "../config/settings.js";
+import { NONE as NO_REGISTER, documentRegister, lastWord, registerOfWord } from "../analysis/grammar/register.js";
+import { doublePassiveSpans, euiCount, longestNounRun, splitSentences } from "../analysis/index.js";
 import { HEADING, PROSE, sectionStartLine, sectionTitle } from "../document/model.js";
+import { dropFences } from "../document/parseMarkdown.js";
 import { codeSpans, plainText } from "../document/plainText.js";
 import { countIn, mean, pstdev, wordCount } from "../text.js";
+import { codeBlocksOf } from "./codeBlocks.js";
 import { entriesFor, matchesIn } from "./dictionaries.js";
 import * as markers from "./markers.js";
+import { buildReaderTrail } from "./readerState.js";
 import { overlap, topicsOf, unionOf } from "./topics.js";
 
 /**
@@ -19,6 +24,7 @@ import { overlap, topicsOf, unionOf } from "./topics.js";
  * @property {number} length 어절 수
  * @property {string} ending
  * @property {string} mood
+ * @property {string} register
  * @property {number} commas
  * @property {string | null} connectorStart
  * @property {number} causal
@@ -81,16 +87,19 @@ import { overlap, topicsOf, unionOf } from "./topics.js";
  * @property {number} questionCount
  * @property {number} readerCallCount
  * @property {[number, string, number, string][]} countPromises (수, 단위, 줄, 원문)
- * @property {[number, string][]} promises
- * @property {[number, string][]} recalls
+ * @property {import("./codeBlocks.js").CodeBlock[]} codeBlocks 코드 펜스를 언어와 본문 줄로 푼 것
+ * @property {import("./readerState.js").ReaderTrail} reader 자리마다의 독자 상태. 약속과 회수 표지는 final 에 있다
  * @property {[string, number, number][]} disabled
+ * @property {import("../document/model.js").Block[]} ignored 설정이 지문에서 뺀 펜스
+ * @property {string} register
+ * @property {number} registerShare
  * @property {SectionPrint} intro
  * @property {SectionPrint[]} bodySections
  */
 
 /**
  * 문장 안의 인용 구간. 블록의 인라인 코드 구간을 문장 좌표로 옮기고 따옴표 쌍을 더한다.
- * @param {import("../analysis/surface/splitSentences.js").Sentence} sentence
+ * @param {import("../analysis/splitSentences.js").Sentence} sentence
  * @param {[number, number][]} blockCodeSpans
  * @returns {[number, number][]}
  */
@@ -114,35 +123,39 @@ function quotedIn(sentence, blockCodeSpans) {
  * @param {import("../document/model.js").Block} block
  * @param {number} paragraphIndex
  * @param {number} sectionIndex
- * @param {import("../analysis/index.js").Analyzer} analyzer
  * @param {import("./dictionaries.js").Entry[]} entries
  * @param {[number, number][]} quoted
  * @returns {SentencePrint}
  */
-function makeSentencePrint(text, index, line, block, paragraphIndex, sectionIndex, analyzer, entries, quoted) {
+function makeSentencePrint(build, text, line, block, sectionIndex, quoted) {
+  const { entries } = build;
   const ending = markers.endingOf(text);
   const deixis = markers
     .matchedSpans(text, "deixis.txt")
     .filter(([start, end]) => !markers.insideAny(start, end, quoted))
     .map(([, , found]) => found);
   const matches = matchesIn(text, entries).filter((m) => !markers.insideAny(m.start, m.end, quoted));
+  const mood = markers.moodOf(text, ending);
   return {
-    index,
+    index: build.sentences.length,
     line,
     text,
     blockIndex: block.index,
-    paragraphIndex,
+    paragraphIndex: build.paragraphs.length,
     sectionIndex,
     length: wordCount(text),
     ending,
-    mood: markers.moodOf(text, ending),
+    mood,
+    register: mood === "평서" ? (registerOfWord(lastWord(text)) ?? NO_REGISTER) : NO_REGISTER,
     commas: markers.countCommas(text),
     connectorStart: markers.connectorStartOf(text),
     causal: markers.countMatches(text, "causalMarkers.txt"),
     deixis,
-    euiCount: analyzer.euiCount(text),
-    nounRun: analyzer.longestNounRun(text),
-    passives: analyzer.doublePassives(text),
+    euiCount: euiCount(text),
+    nounRun: longestNounRun(text),
+    passives: doublePassiveSpans(text)
+      .filter(([start, end]) => !markers.insideAny(start, end, quoted))
+      .map(([, , surface]) => surface),
     hedges: markers.countMatches(text, "hedges.txt"),
     numbers: markers.countNumbers(text),
     topics: topicsOf(text),
@@ -164,11 +177,11 @@ function makeSentencePrint(text, index, line, block, paragraphIndex, sectionInde
  * @param {boolean} followsProseDirectly
  * @returns {ParagraphPrint}
  */
-function makeParagraphPrint(sentences, index, block, sectionIndex, previous, followsProseDirectly) {
+function makeParagraphPrint(build, sentences, block, sectionIndex, previous, followsProseDirectly) {
   const lengths = sentences.map((s) => s.length);
   const topics = unionOf(sentences.map((s) => s.topics));
   return {
-    index,
+    index: build.paragraphs.length,
     blockIndex: block.index,
     sectionIndex,
     startLine: block.startLine,
@@ -189,13 +202,13 @@ function makeParagraphPrint(sentences, index, block, sectionIndex, previous, fol
 /**
  * @param {import("../document/model.js").Section} section
  * @param {number} sectionIndex
- * @param {import("../analysis/index.js").Analyzer} analyzer
  * @param {import("./dictionaries.js").Entry[]} entries
  * @param {SentencePrint[]} sentences
  * @param {ParagraphPrint[]} paragraphs
  * @returns {SectionPrint}
  */
-function buildSection(section, sectionIndex, analyzer, entries, sentences, paragraphs) {
+function buildSection(build, section, sectionIndex) {
+  const { sentences, paragraphs } = build;
   /** @type {ParagraphPrint[]} */
   const sectionParagraphs = [];
   /** @type {import("../document/model.js").Block | null} */
@@ -209,19 +222,18 @@ function buildSection(section, sectionIndex, analyzer, entries, sentences, parag
     const blockCodeSpans = codeSpans(block.text, text);
     /** @type {SentencePrint[]} */
     const blockSentences = [];
-    for (const sentence of analyzer.sentences(text)) {
+    for (const sentence of splitSentences(text)) {
       const line = block.startLine + countIn(text, "\n", sentence.start);
-      const index = sentences.length + blockSentences.length;
       const quoted = quotedIn(sentence, blockCodeSpans);
-      blockSentences.push(
-        makeSentencePrint(sentence.text, index, line, block, paragraphs.length, sectionIndex, analyzer, entries, quoted),
-      );
+      const made = makeSentencePrint(build, sentence.text, line, block, sectionIndex, quoted);
+      // 만든 자리에서 바로 쌓는다. 다음 문장의 index 가 이 길이에서 나오므로 미루면 셈이 어긋난다.
+      sentences.push(made);
+      blockSentences.push(made);
     }
-    sentences.push(...blockSentences);
     const previous = sectionParagraphs.length ? sectionParagraphs[sectionParagraphs.length - 1] : null;
     const paragraph = makeParagraphPrint(
+      build,
       blockSentences,
-      paragraphs.length,
       block,
       sectionIndex,
       previous,
@@ -246,23 +258,26 @@ function buildSection(section, sectionIndex, analyzer, entries, sentences, parag
 
 /**
  * @param {import("../document/model.js").Document} doc
- * @param {import("../analysis/index.js").Analyzer} analyzer
  * @param {import("../config/settings.js").Config} [config]
  * @returns {DocumentPrint}
  */
-export function buildFingerprint(doc, analyzer, config = defaultConfig()) {
-  const entries = entriesFor(config);
-  /** @type {SentencePrint[]} */
-  const sentences = [];
-  /** @type {ParagraphPrint[]} */
-  const paragraphs = [];
+export function buildFingerprint(doc, config = defaultConfig()) {
+  // 코드도 산문도 아닌 펜스는 지문에 들어오기 전에 뺀다. 모든 진입점이 여기를 지나므로 한 자리면 된다.
+  doc = dropFences(doc, config.ignoreFences);
+  const build = { entries: entriesFor(config), sentences: /** @type {SentencePrint[]} */ ([]), paragraphs: /** @type {ParagraphPrint[]} */ ([]) };
+  const { sentences, paragraphs } = build;
   const sections = doc.sections.map((section, index) =>
-    buildSection(section, index, analyzer, entries, sentences, paragraphs),
+    buildSection(build, section, index),
   );
   const headingBlocks = doc.blocks.filter((b) => b.kind === HEADING);
   /** @type {[number, string, number][]} */
   const headings = headingBlocks.map((b) => [b.level, b.text, b.startLine]);
   const headingQuestions = headingBlocks.filter((b) => b.text.includes("?")).length;
+  const [register, registerShare] = documentRegister(
+    sentences.filter((sentence) => sentence.mood === "평서").map((sentence) => lastWord(sentence.text)),
+    config.registerMinShare,
+  );
+  const codeBlocks = codeBlocksOf(doc.blocks);
   return {
     path: doc.path,
     frontmatter: { ...doc.frontmatter },
@@ -275,9 +290,12 @@ export function buildFingerprint(doc, analyzer, config = defaultConfig()) {
     questionCount: sentences.filter((s) => s.mood === "의문").length + headingQuestions,
     readerCallCount: sentences.filter((s) => s.readerCall || s.mood === "명령").length,
     countPromises: sentences.flatMap((s) => s.countPromises.map(([n, unit, text]) => [n, unit, s.line, text])),
-    promises: sentences.flatMap((s) => s.promises.map((text) => [s.line, text])),
-    recalls: sentences.flatMap((s) => s.recalls.map((text) => [s.line, text])),
+    codeBlocks,
+    reader: buildReaderTrail(doc.blocks, codeBlocks, sentences),
+    register,
+    registerShare,
     disabled: doc.disabled,
+    ignored: doc.ignored,
     intro: sections[0],
     bodySections: sections.filter((s) => !s.isIntro),
   };

package/src/{rules/shared → fingerprint}/codeBlocks.js

@@ -1,11 +1,12 @@
 // @ts-check
 /**
- * 코드 블록을 언어와 본문으로 나눈다. code 부류 규칙이 함께 쓴다. 파이썬 rules/shared/codeBlocks.py 와 같다.
+ * 코드 블록을 언어와 본문으로 나눈다. 지문이 한 번 만들고 (DocumentPrint.codeBlocks) code 부류 규칙과 독자 상태가
+ * 읽는다. 파이썬 fingerprint/codeBlocks.py 와 같다.
  * 펜스 첫 줄의 언어 표기 (```python) 를 읽고 본문 줄에 원문 줄 번호를 붙인다. text 펜스는 출력이다.
  */
-import { CODE } from "../../document/model.js";
+import { CODE } from "../document/model.js";
+import { fenceLanguage } from "../document/parseMarkdown.js";
 
-const FENCE_LANGUAGE = /^\s*(?:```|~~~)\s*([A-Za-z0-9_+-]*)/;
 const CLOSING_FENCE = /^\s*(?:```|~~~)\s*$/;
 
 /**
@@ -18,20 +19,19 @@ const CLOSING_FENCE = /^\s*(?:```|~~~)\s*$/;
  * @property {boolean} isOutput
  */
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc @returns {CodeBlock[]} */
-export function codeBlocksOf(doc) {
+/** @param {import("../document/model.js").Block[]} blocks @returns {CodeBlock[]} */
+export function codeBlocksOf(blocks) {
   /** @type {CodeBlock[]} */
-  const blocks = [];
-  for (const block of doc.blocks) {
+  const found = [];
+  for (const block of blocks) {
     if (block.kind !== CODE) continue;
     const raw = block.text.split("\n");
-    const match = FENCE_LANGUAGE.exec(raw[0]);
-    const language = (match ? match[1] : "").toLowerCase();
+    const language = fenceLanguage(block.text);
     let body = raw.slice(1);
     if (body.length && CLOSING_FENCE.test(body[body.length - 1])) body = body.slice(0, -1);
     /** @type {[number, string][]} */
     const lines = body.map((line, offset) => [block.startLine + 1 + offset, line]);
-    blocks.push({
+    found.push({
       index: block.index,
       startLine: block.startLine,
       language,
@@ -40,5 +40,5 @@ export function codeBlocksOf(doc) {
       isOutput: ["text", "", "output", "console"].includes(language),
     });
   }
-  return blocks;
+  return found;
 }

package/src/fingerprint/codeMarkers.js

@@ -0,0 +1,73 @@
+// @ts-check
+/**
+ * 코드 줄에서 파일의 공급과 수요를 읽는다. 어떤 줄이 파일을 만들고 (쓰기, 폴더 만들기) 어떤 줄이 파일을 읽는가.
+ * 파이썬 fingerprint/codeMarkers.py 와 같다. 줄마다 대조하므로 여러 줄에 걸친 호출은 보지 않는다.
+ */
+
+const QUOTED = "\\(\\s*[\"']([^\"'\\n]+)[\"']";
+const READS = new RegExp(
+  "\\b(?:read_csv|read_excel|read_parquet|read_json|read_sql|read_table|read_ndjson|scan_csv|scan_parquet|scan_ndjson|" +
+    "read_text|read_bytes|loadtxt|imread|load_workbook)" + QUOTED,
+  "g",
+);
+const OPENS = new RegExp("\\bopen" + QUOTED + "\\s*(?:,\\s*(?:mode\\s*=\\s*)?[\"']([^\"']*)[\"'])?", "g");
+const WRITES = new RegExp(
+  "\\b(?:to_csv|to_excel|to_parquet|to_json|to_sql|write_csv|write_parquet|write_json|write_ndjson|sink_parquet|sink_csv|" +
+    "write_text|write_bytes|savefig|save|imwrite|savetxt|dump)" + QUOTED,
+  "g",
+);
+const SHELL_WRITES = /(?:>>?|-o|-O|--output|Out-File)\s*["']?([\w./\\-]+\.[A-Za-z0-9]+)/g;
+const SQL_PATHS = /FROM\s+'([^']+\.(?:csv|parquet|json|xlsx))'/gi;
+const MAKES_DIR = /(?:mkdir(?:\s+-p)?|makedirs|md)\s*\(?\s*["']?([\w./\\-]+)|Path\(\s*["']([^"']+)["']\s*\)\.mkdir/g;
+/** open 의 모드에 이 글자가 있으면 쓰기다. 없으면 (기본 r) 읽기다. */
+const WRITE_MODES = [..."wax"];
+
+/** @param {string} path */
+export function fileName(path) {
+  const parts = path.replace(/\\/g, "/").replace(/\/+$/, "").split("/");
+  return parts[parts.length - 1];
+}
+
+/** @param {string | undefined} mode */
+function isWriteMode(mode) {
+  return WRITE_MODES.some((flag) => (mode ?? "r").includes(flag));
+}
+
+/** @param {RegExp} pattern @param {string} text @param {number} group */
+function all(pattern, text, group) {
+  const found = [];
+  for (const match of text.matchAll(pattern)) if (match[group] !== undefined) found.push(match[group]);
+  return found;
+}
+
+/**
+ * 코드 줄들이 만드는 [파일 이름, 폴더 이름]. 쓰기 함수, 셸 리다이렉션, 쓰기 모드의 open, mkdir 을 본다.
+ * @param {string[]} lines
+ * @returns {[Set<string>, Set<string>]}
+ */
+export function createdIn(lines) {
+  /** @type {Set<string>} */
+  const files = new Set();
+  /** @type {Set<string>} */
+  const dirs = new Set();
+  for (const code of lines) {
+    for (const path of all(WRITES, code, 1)) files.add(fileName(path));
+    for (const path of all(SHELL_WRITES, code, 1)) files.add(fileName(path));
+    for (const match of code.matchAll(OPENS)) if (isWriteMode(match[2])) files.add(fileName(match[1]));
+    for (const match of code.matchAll(MAKES_DIR)) dirs.add((match[1] ?? match[2]).replace(/\\/g, "/").split("/")[0]);
+  }
+  return [files, dirs];
+}
+
+/** 한 줄이 읽는 경로. 읽기 함수, 읽기 모드의 open, SQL 의 FROM 차례다. @param {string} code */
+export function readsIn(code) {
+  const reads = all(READS, code, 1);
+  for (const match of code.matchAll(OPENS)) if (!isWriteMode(match[2])) reads.push(match[1]);
+  reads.push(...all(SQL_PATHS, code, 1));
+  return reads;
+}
+
+/** 한 줄이 쓰기 함수로 쓰는 경로 그대로. 그 경로의 폴더가 있는지 볼 때 쓴다. @param {string} code */
+export function writeTargets(code) {
+  return all(WRITES, code, 1);
+}

package/src/fingerprint/markers.js

@@ -8,6 +8,8 @@ import { compile, escape } from "../regex.js";
 
 const TRAILING = /[\s.?!"'”’)\]]+$/;
 const NUMBER = /\d+(?:[.,]\d+)*/g;
+/** 값으로 견주는 수. NUMBER 는 수의 개수를 세고 이것은 수의 정체를 센다. 천 단위 쉼표까지 한 수로 읽는다. */
+const NUMERAL = /\d[\d,]*(?:\.\d+)?/g;
 const COMMA = /,/g;
 // 따옴표 쌍. 안은 사용이 아니라 인용이다. 작은따옴표는 앞이 문장 첫머리나 공백이나 여는 괄호일 때만.
 const QUOTE_PAIRS = [
@@ -165,6 +167,13 @@ export function countPromisesIn(text) {
 }
 
 /** @param {string} text */
+/** 글에 나온 수의 정체 (천 단위 쉼표를 뗀 꼴). 독자 상태가 쌓고 numberOrphan 이 견준다. @param {string} text @returns {Set<string>} */
+export function numeralsIn(text) {
+  const found = new Set();
+  for (const match of text.matchAll(NUMERAL)) found.add(match[0].replaceAll(",", ""));
+  return found;
+}
+
 export function countNumbers(text) {
   return [...text.matchAll(NUMBER)].length;
 }

package/src/fingerprint/readerState.js

@@ -0,0 +1,126 @@
+// @ts-check
+/**
+ * 독자 상태. 글을 위에서 아래로 읽는 독자가 어느 자리에서 무엇을 손에 들고 무엇을 이미 보았는가.
+ * 파이썬 fingerprint/readerState.py 와 같다. reader 기제의 규칙은 어느 자리가 요구하는 것을 그 자리의 상태에
+ * 대 본다. 상태는 블록과 문장 순서로 쌓이고 한 번 쌓은 것은 바뀌지 않는다. 집합은 고치지 않는다.
+ */
+import { CODE, PROSE } from "../document/model.js";
+import { createdIn } from "./codeMarkers.js";
+import { numeralsIn } from "./markers.js";
+
+/**
+ * 한 자리 (문장 하나 또는 블록 하나) 를 읽기 직전의 독자.
+ * @typedef {object} ReaderState
+ * @property {import("./build.js").SentencePrint | null} previous 바로 앞에 읽은 산문 문장
+ * @property {Set<string>} recent 손에 든 화제어. 바로 앞 문장의 것이고 앞 문장이 없으면 빈 집합
+ * @property {Set<string>} known 이 자리 앞까지 산문에 나온 화제어 전부
+ * @property {Set<string>} numerals 지금까지 산문과 블록에 나온 수 (천 단위 쉼표를 뗀 꼴)
+ * @property {Set<string>} files 앞선 코드 블록이 만든 파일 이름과 폴더
+ * @property {number} sentencesRead 지금까지 읽은 산문 문장 수
+ * @property {[number, string][]} promises 지금까지 뒤로 미룬 표지 (줄, 원문)
+ * @property {[number, string][]} recalls 지금까지 앞을 회수한 표지 (줄, 원문)
+ */
+
+/**
+ * 자리마다의 독자 상태. 문장은 index 로, 블록은 index 로 찾는다.
+ * @typedef {object} ReaderTrail
+ * @property {ReaderState[]} beforeSentence
+ * @property {ReaderState[]} beforeBlock
+ * @property {ReaderState} final 글을 다 읽은 독자
+ * @property {(blockIndex: number, name: string) => boolean} mentionedBefore 블록보다 앞선 산문이 그 이름을 불렀는가
+ */
+
+/** @type {Set<string>} */
+const NOTHING = new Set();
+
+/**
+ * 현재 문장의 화제가 직전 독자에게 새 것인지 이미 손에 든 것인지 네 꼴로 줄인다.
+ * @param {import("./build.js").SentencePrint} sentence
+ * @param {ReaderState} state
+ */
+export function readerKind(sentence, state) {
+  if (!sentence.topics.size) return "none";
+  if ([...sentence.topics].some((topic) => state.recent.has(topic))) return "recent";
+  if ([...sentence.topics].some((topic) => state.known.has(topic))) return "known";
+  return "new";
+}
+
+/** @param {Set<string>} base @param {Set<string>} added */
+function union(base, added) {
+  if (!added.size) return base;
+  const out = new Set(base);
+  for (const value of added) out.add(value);
+  return out;
+}
+
+/** @param {ReaderState} state @param {import("./build.js").SentencePrint} sentence @returns {ReaderState} */
+function afterSentence(state, sentence) {
+  return {
+    previous: sentence,
+    recent: sentence.topics,
+    known: union(state.known, sentence.topics),
+    numerals: union(state.numerals, numeralsIn(sentence.text)),
+    files: state.files,
+    sentencesRead: state.sentencesRead + 1,
+    promises: [...state.promises, ...sentence.promises.map((text) => /** @type {[number, string]} */ ([sentence.line, text]))],
+    recalls: [...state.recalls, ...sentence.recalls.map((text) => /** @type {[number, string]} */ ([sentence.line, text]))],
+  };
+}
+
+/**
+ * 산문 아닌 블록을 지난 독자. 수는 어느 블록에서든 보고 파일은 코드 블록이 만든다.
+ * @param {ReaderState} state
+ * @param {import("../document/model.js").Block} block
+ * @param {import("./codeBlocks.js").CodeBlock | undefined} code
+ * @returns {ReaderState}
+ */
+function afterBlock(state, block, code) {
+  let files = state.files;
+  if (code) {
+    const [made, dirs] = createdIn(code.lines.map(([, line]) => line));
+    files = union(union(files, made), dirs);
+  }
+  return { ...state, numerals: union(state.numerals, numeralsIn(block.text)), files };
+}
+
+/**
+ * 블록 순서로 한 번 지나며 자리마다의 상태를 적는다. 산문 블록은 문장 하나씩, 나머지는 블록째 읽는다.
+ * @param {import("../document/model.js").Block[]} blocks
+ * @param {import("./codeBlocks.js").CodeBlock[]} codeBlocks
+ * @param {import("./build.js").SentencePrint[]} sentences
+ * @returns {ReaderTrail}
+ */
+export function buildReaderTrail(blocks, codeBlocks, sentences) {
+  const codeByIndex = new Map(codeBlocks.map((code) => [code.index, code]));
+  /** @type {ReaderState[]} */
+  const beforeSentence = [];
+  /** @type {ReaderState[]} */
+  const beforeBlock = [];
+  /** @type {ReaderState} */
+  let state = { previous: null, recent: NOTHING, known: NOTHING, numerals: NOTHING, files: NOTHING, sentencesRead: 0, promises: [], recalls: [] };
+  let position = 0;
+  for (const block of blocks) {
+    beforeBlock.push(state);
+    if (block.kind === PROSE) {
+      while (position < sentences.length && sentences[position].blockIndex === block.index) {
+        beforeSentence.push(state);
+        state = afterSentence(state, sentences[position]);
+        position += 1;
+      }
+    } else {
+      state = afterBlock(state, block, block.kind === CODE ? codeByIndex.get(block.index) : undefined);
+    }
+  }
+  if (position !== sentences.length) {
+    throw new Error(`문장 ${sentences.length - position}개가 어느 블록에도 안 든다. 문장과 블록의 순서가 어긋났다`);
+  }
+  return {
+    beforeSentence,
+    beforeBlock,
+    final: state,
+    mentionedBefore(blockIndex, name) {
+      const read = beforeBlock[blockIndex].sentencesRead;
+      return sentences.slice(0, read).some((sentence) => sentence.text.includes(name));
+    },
+  };
+}