hanlint 0.0.7 → 0.0.9

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));
+    },
+  };
+}

package/src/fingerprint/sourceSentence.js

@@ -0,0 +1,37 @@
+// @ts-check
+/** 평문 지문의 문장을 마크다운 표식을 보존한 원문 문장에 다시 맞춘다. */
+import { splitSentences } from "../analysis/splitSentences.js";
+import { plainText } from "../document/plainText.js";
+
+/**
+ * @param {import("./build.js").DocumentPrint} document
+ * @returns {Map<number, string>}
+ */
+export function sourceSentenceTexts(document) {
+  /** @type {Map<number, import("./build.js").SentencePrint[]>} */
+  const byBlock = new Map();
+  for (const sentence of document.sentences) {
+    const found = byBlock.get(sentence.blockIndex) ?? [];
+    found.push(sentence);
+    byBlock.set(sentence.blockIndex, found);
+  }
+  const blocks = new Map(document.blocks.map((block) => [block.index, block]));
+  const result = new Map();
+  for (const [blockIndex, plainSentences] of byBlock) {
+    const block = blocks.get(blockIndex);
+    if (!block) continue;
+    const rawSentences = splitSentences(block.text);
+    if (rawSentences.length !== plainSentences.length) continue;
+    if (plainSentences.some((plain, index) => plainText(rawSentences[index].text) !== plain.text)) continue;
+    plainSentences.forEach((plain, index) => result.set(plain.index, rawSentences[index].text));
+  }
+  return result;
+}
+
+/**
+ * @param {import("./build.js").DocumentPrint} document
+ * @param {import("./build.js").SentencePrint} sentence
+ */
+export function sourceSentenceText(document, sentence) {
+  return sourceSentenceTexts(document).get(sentence.index);
+}

package/src/fingerprint/topics.js

@@ -1,6 +1,6 @@
 // @ts-check
 /** 화제어 집합. 조사를 뗀 명사 어절의 근사. 파이썬 fingerprint/topics.py 와 같다. */
-import { stripJosa, tailOf, words } from "../analysis/surface/tokenize.js";
+import { stripJosa, tailOf, words } from "../analysis/tokenize.js";
 import { loadLines } from "../data/load.js";
 
 const WORD = /^[가-힣A-Za-z][가-힣A-Za-z0-9]*$/;

package/src/index.js

@@ -8,11 +8,10 @@
  * ```
  *
  * 합격과 불합격을 판정하지 않는다. 지적 목록이 비어 있다는 것은 세어서 잡히는 결함이 없다는 뜻이다.
- * 지문 지도 (audit, map), 프로파일, kiwi 정밀 모드는 파이썬 패키지에 있다.
+ * 지문 지도 (audit, map) 와 프로파일은 파이썬 패키지에 있다.
  */
 import { readFileSync } from "node:fs";
 
-import { makeAnalyzer } from "./analysis/index.js";
 import { loadConfig } from "./config/loadConfig.js";
 import { configFromMapping, defaultConfig } from "./config/settings.js";
 import { loadVersion } from "./data/load.js";
@@ -25,19 +24,6 @@ import { ruleDoc, ruleNames, ruleSummary, runAll } from "./rules/registry.js";
 export { applyFixes, configFromMapping, defaultConfig, fingerprintDict, loadConfig, ruleDoc, ruleNames, ruleSummary };
 export const version = loadVersion();
 
-/** @type {Map<string, import("./analysis/index.js").Analyzer>} */
-const analyzers = new Map();
-
-/** @param {import("./config/settings.js").Config} config */
-export function analyzerFor(config) {
-  let analyzer = analyzers.get(config.analyzer);
-  if (!analyzer) {
-    analyzer = makeAnalyzer(config.analyzer);
-    analyzers.set(config.analyzer, analyzer);
-  }
-  return analyzer;
-}
-
 /**
  * 글을 한 번 읽어 지문을 만든다.
  * @param {string} text
@@ -45,7 +31,7 @@ export function analyzerFor(config) {
  * @param {string | null} [path]
  */
 export function fingerprint(text, config = defaultConfig(), path = null) {
-  return buildFingerprint(parseMarkdown(text, path), analyzerFor(config), config);
+  return buildFingerprint(parseMarkdown(text, path), config);
 }
 
 /**

package/src/report/compactReport.js

@@ -1,9 +1,14 @@
 // @ts-check
 /** 한 줄에 지적 하나. AI 와 스크립트가 읽는 꼴이다. 파이썬 report/compactReport.py 와 같은 글자다. */
 
+/** 줄바꿈과 이어진 공백을 하나로 눕힌다. 한 줄은 이 꼴의 계약이다. @param {string} text */
+function flat(text) {
+  return text.split(/\s+/).filter(Boolean).join(" ");
+}
+
 /** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
 export function renderCompact(path, findings) {
   return findings
-    .map((f) => `${path}:${f.line} [${f.rule}] ${f.why}` + (f.fix ? `  고친 뒤: ${f.fix}` : ""))
+    .map((f) => `${path}:${f.line} [${f.rule}] ${flat(f.why)}` + (f.fix ? `  고친 뒤: ${flat(f.fix)}` : ""))
     .join("\n");
 }

package/src/report/fingerprintJson.js

@@ -4,12 +4,14 @@
  * 아래층을 index 로 가리킨다. 실수는 소수 여섯째 자리로 맞춰 두 구현이 같은 글자를 낸다.
  */
 
+import { roundHalfEven } from "../text.js";
+
 export const LAYERS = ["all", "sentences", "paragraphs", "sections", "document"];
 
 /** @param {number | null} value */
 function num(value) {
   if (value === null) return null;
-  return Math.round(value * 1e6) / 1e6;
+  return roundHalfEven(value, 6);
 }
 
 /** @param {Set<string>} set */
@@ -29,6 +31,7 @@ function sentenceDict(s) {
     length: s.length,
     ending: s.ending,
     mood: s.mood,
+    register: s.register,
     commas: s.commas,
     connectorStart: s.connectorStart,
     causal: s.causal,
@@ -102,9 +105,11 @@ function documentDict(doc) {
     sectionCount: doc.sections.length,
     questionCount: doc.questionCount,
     readerCallCount: doc.readerCallCount,
+    register: doc.register,
+    registerShare: roundHalfEven(doc.registerShare, 3),
     countPromises: doc.countPromises.map(([n, unit, line, text]) => [n, unit, line, text]),
-    promises: doc.promises.map(([line, text]) => [line, text]),
-    recalls: doc.recalls.map(([line, text]) => [line, text]),
+    promises: doc.reader.final.promises.map(([line, text]) => [line, text]),
+    recalls: doc.reader.final.recalls.map(([line, text]) => [line, text]),
     disabled: doc.disabled.map(([name, start, end]) => [name, start, end]),
   };
 }

package/src/report/jsonReport.js

@@ -1,13 +1,60 @@
 // @ts-check
-/** 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다. */
+/**
+ * 기계가 읽는 꼴. 평가 루프의 0층 입력이다. 파이썬 json.dumps(indent=2, ensure_ascii=False) 와 같은 글자다.
+ * 지적마다 `exemplar` 를 붙인다. 승인 원문 완전 일치 `patch`는 맞는 지적에만 별도로 붙인다.
+ * 실제 수정 차이는 파이썬의 exemplarLift와 patchMemory 탐침에서 따로 잰다.
+ */
+import { exemplarFor } from "../data/exemplars.js";
 import { findingAsDict } from "../rules/finding.js";
+import { exemplarInRegister } from "./registerMatch.js";
+import { operationGuidance } from "./operationMatch.js";
+import { patchData } from "./patchMatch.js";
+
+/** @param {import("../rules/finding.js").Finding} finding @param {string | null | undefined} register @param {string | null | undefined} preset @param {import("../data/exemplars.js").Exemplar[]} customExemplars */
+function findingWithExemplar(finding, document, register, preset, customExemplars, patches) {
+  const data = findingAsDict(finding);
+  const exemplar = exemplarFor(finding.rule, preset, customExemplars);
+  if (exemplar) {
+    const adapted = exemplarInRegister(exemplar, register);
+    data.exemplar = { before: adapted.before, after: adapted.after, moved: adapted.moved };
+  }
+  const selected = patchData(document, finding, preset, patches);
+  if (selected) data.patch = selected;
+  return data;
+}
 
 /**
  * @param {Map<string, import("../rules/finding.js").Finding[]>} results
  * @param {string | null} [configLabel]
+ * @param {Map<string, string> | null} [registers]
+ * @param {string | null} [preset]
+ * @param {import("../data/exemplars.js").Exemplar[]} [customExemplars]
+ * @param {Map<string, import("../fingerprint/build.js").DocumentPrint> | null} [documents]
+ * @param {import("../data/patches.js").Patch[]} [patches]
+ * @param {import("../data/operations.js").SurfaceOperation[]} [operations]
+ * @param {string[]} [protectedTerms]
  */
-export function renderJson(results, configLabel = null) {
-  const files = [...results].map(([path, findings]) => ({ path, findings: findings.map(findingAsDict) }));
+export function renderJson(
+  results,
+  configLabel = null,
+  registers = null,
+  preset = null,
+  customExemplars = [],
+  documents = null,
+  patches = [],
+  operations = [],
+  protectedTerms = [],
+) {
+  const files = [...results].map(([path, findings]) => {
+    const document = documents?.get(path);
+    const entry = {
+      path,
+      findings: findings.map((finding) => findingWithExemplar(finding, document, registers?.get(path), preset, customExemplars, patches)),
+    };
+    const selectedOperations = operationGuidance(document, findings, preset, operations, patches, protectedTerms);
+    if (selectedOperations.length) entry.operations = selectedOperations;
+    return entry;
+  });
   /** @type {Record<string, unknown>} */
   const data = { version: 1 };
   if (configLabel !== null) data.config = configLabel;

package/src/report/operationMatch.js

@@ -0,0 +1,31 @@
+// @ts-check
+/** 현재 문장에 승인 표면 치환이 안전하게 하나만 적용되는지 계산한다. */
+import { operationData, operationFor } from "../data/operations.js";
+import { sourceSentenceTexts } from "../fingerprint/sourceSentence.js";
+import { selectedPatch } from "./patchMatch.js";
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding[]} findings
+ * @param {string | null | undefined} preset
+ * @param {import("../data/operations.js").SurfaceOperation[]} operations
+ * @param {import("../data/patches.js").Patch[]} [patches]
+ * @param {string[]} [protectedTerms]
+ */
+export function operationGuidance(document, findings, preset, operations, patches = [], protectedTerms = []) {
+  if (!document || !preset || !operations.length) return [];
+  const reserved = new Set(findings.filter((finding) => finding.at >= 0 && finding.fix !== null).map((finding) => finding.at));
+  for (const finding of findings) {
+    if (finding.at >= 0 && selectedPatch(document, finding, preset, patches)) reserved.add(finding.at);
+  }
+  const sourceTexts = sourceSentenceTexts(document);
+  const guidance = [];
+  for (const sentence of document.sentences) {
+    if (reserved.has(sentence.index)) continue;
+    const sourceText = sourceTexts.get(sentence.index);
+    if (sourceText === undefined) continue;
+    const applied = operationFor(sourceText, preset, operations, protectedTerms);
+    if (applied) guidance.push({ line: sentence.line, operation: operationData(applied, preset) });
+  }
+  return guidance;
+}

package/src/report/patchMatch.js

@@ -0,0 +1,44 @@
+// @ts-check
+/** 현재 지적과 지문을 승인 패치의 선택 조건에 맞댄다. */
+import { flatSentence, patchFor } from "../data/patches.js";
+import { readerKind } from "../fingerprint/readerState.js";
+import { sourceSentenceText } from "../fingerprint/sourceSentence.js";
+import { SENTENCE, localCue } from "../rules/finding.js";
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding} finding
+ * @param {string | null | undefined} preset
+ * @param {import("../data/patches.js").Patch[]} patches
+ */
+export function selectedPatch(document, finding, preset, patches) {
+  if (!patches.length || !document || finding.scope !== SENTENCE || finding.at < 0 || finding.at >= document.sentences.length) return undefined;
+  const sentence = document.sentences[finding.at];
+  const sourceText = sourceSentenceText(document, sentence);
+  if (!sourceText) return undefined;
+  const state = document.reader.beforeSentence[finding.at];
+  return patchFor(finding.rule, preset, sourceText, sentence.text, localCue(finding), readerKind(sentence, state), patches);
+}
+
+/**
+ * @param {import("../fingerprint/build.js").DocumentPrint | null | undefined} document
+ * @param {import("../rules/finding.js").Finding} finding
+ * @param {string | null | undefined} preset
+ * @param {import("../data/patches.js").Patch[]} patches
+ */
+export function patchData(document, finding, preset, patches) {
+  const patch = selectedPatch(document, finding, preset, patches);
+  if (!patch || !preset) return undefined;
+  return {
+    before: patch.before,
+    after: patch.after,
+    moved: patch.moved,
+    match: {
+      sourceText: flatSentence(patch.sourceText),
+      sentence: flatSentence(patch.sentence),
+      preset,
+      cue: patch.cue,
+      reader: patch.reader,
+    },
+  };
+}

package/src/report/registerMatch.js

@@ -0,0 +1,40 @@
+// @ts-check
+/** 한 문체로 저장한 본보기와 문형을 검사한 글의 문체에 맞춘다. */
+import { HAPNIDA, REGISTERS, convertTemplate } from "../analysis/grammar/index.js";
+
+/** 섞임과 없음은 데이터 정본의 합니다체를 유지한다. @param {string | null | undefined} register */
+export function targetRegister(register) {
+  return register && REGISTERS.includes(register) ? register : HAPNIDA;
+}
+
+/** @param {import("../data/exemplars.js").Exemplar} exemplar @param {string | null | undefined} register */
+export function exemplarInRegister(exemplar, register) {
+  const target = targetRegister(register);
+  const before = convertTemplate(exemplar.before, target);
+  const after = convertTemplate(exemplar.after, target);
+  if (before.skipped || after.skipped) {
+    throw new Error(
+      exemplar.rule + " 본보기의 서술어를 못 풀었다: " + (before.skipped + after.skipped),
+    );
+  }
+  return { rule: exemplar.rule, before: before.text, after: after.text, moved: exemplar.moved, presets: exemplar.presets };
+}
+
+/** @param {import("../data/patterns.js").Pattern} pattern @param {string | null | undefined} register */
+export function patternInRegister(pattern, register) {
+  const target = targetRegister(register);
+  const form = convertTemplate(pattern.form, target);
+  const example = convertTemplate(pattern.example, target);
+  const instead = convertTemplate(pattern.instead, target);
+  const skipped = form.skipped + example.skipped + instead.skipped;
+  if (skipped) throw new Error(pattern.name + " 문형의 서술어를 못 풀었다: " + skipped);
+  return {
+    name: pattern.name,
+    form: form.text,
+    when: pattern.when,
+    example: example.text,
+    instead: instead.text,
+    avoids: pattern.avoids,
+    source: pattern.source,
+  };
+}

package/src/report/textReport.js

@@ -1,8 +1,42 @@
 // @ts-check
-/** 사람이 읽는 지적 목록. `파일:줄` 로 시작해 편집기가 바로 연다. 파이썬 report/textReport.py 와 같은 글자다. */
+/**
+ * 사람이 읽는 지적 목록. `파일:줄` 로 시작해 편집기가 바로 연다. 파이썬 report/textReport.py 와 같은 글자다.
+ * 끝에 본보기를 붙인다. 전과 후를 제 줄에 둔다. 왜 한 줄이 아닌지는 파이썬 report/textReport.py 가 소유한다.
+ */
+import { exemplarFor, shortened, twoLines } from "../data/exemplars.js";
+import { exemplarInRegister } from "./registerMatch.js";
 
-/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings */
-export function renderText(path, findings) {
+/** 그 글에 나온 규칙의 본보기. 이름 순이고 규칙 하나에 세 줄이다. @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} register @param {string | null | undefined} preset @param {import("../data/exemplars.js").Exemplar[]} customExemplars */
+function exemplarLines(findings, register, preset, customExemplars) {
+  const lines = [];
+  let cut = false;
+  for (const name of [...new Set(findings.map((f) => f.rule))].sort()) {
+    let exemplar = exemplarFor(name, preset, customExemplars);
+    if (!exemplar) continue;
+    exemplar = exemplarInRegister(exemplar, register);
+    const [before, after] = twoLines(exemplar);
+    cut = cut || shortened(exemplar);
+    lines.push(`  [${name}]`, `    전  ${before}`, `    후  ${after}`);
+  }
+  if (!lines.length) return [];
+  const head = "본보기 (고치기 전, 고친 뒤)";
+  return [cut ? `${head}. 잘린 것은 hanlint explain <규칙>` : head, ...lines];
+}
+
+/** 본보기 아래에 붙이는 선택지. 지적 자리별이며 순위는 없다. @param {import("../rules/finding.js").Finding[]} findings */
+function candidateLines(findings) {
+  const chosen = findings.filter((finding) => finding.candidates.length);
+  if (!chosen.length) return [];
+  const lines = ["후보 (기계가 고르지 않음)"];
+  for (const finding of chosen) {
+    lines.push(`  ${finding.line}줄 [${finding.rule}]`);
+    for (const candidate of finding.candidates) lines.push(`    - ${candidate.text} (${candidate.why})`);
+  }
+  return lines;
+}
+
+/** @param {string} path @param {import("../rules/finding.js").Finding[]} findings @param {string | null | undefined} [register] @param {string | null | undefined} [preset] @param {import("../data/exemplars.js").Exemplar[]} [customExemplars] */
+export function renderText(path, findings, register = null, preset = null, customExemplars = []) {
   if (!findings.length) return `${path}  집은 자리 없음`;
   const errors = findings.filter((f) => f.severity === "error").length;
   const notices = findings.length - errors;
@@ -14,6 +48,8 @@ export function renderText(path, findings) {
     if (f.fix) lines.push(`  고친 뒤: ${f.fix}`);
     lines.push("");
   }
-  lines.push(`규칙이 왜 있는지 보려면: hanlint explain ${findings[0].rule}`);
-  return lines.join("\n");
+  lines.push(...exemplarLines(findings, register, preset, customExemplars));
+  const candidates = candidateLines(findings);
+  if (candidates.length) lines.push("", ...candidates);
+  return lines.join("\n").replace(/\n+$/, "");
 }

package/src/rules/code/duplicateBlock.js

@@ -1,8 +1,9 @@
 // @ts-check
+import { roundHalfEven } from "../../text.js";
 import { DOCUMENT, NOTICE, finding } from "../finding.js";
-import { codeBlocksOf } from "../shared/codeBlocks.js";
 
 export const name = "duplicateBlock";
+export const mechanism = "repeat";
 const MIN_LINES = 4;
 
 /** 줄 다중집합의 겹침 비. 2 * 공통 / (a + b). @param {string[]} a @param {string[]} b */
@@ -28,7 +29,7 @@ function similarity(a, b) {
  */
 export function run(doc, config) {
   const findings = [];
-  const blocks = codeBlocksOf(doc).filter((b) => b.lines.filter(([, line]) => line.trim()).length >= MIN_LINES);
+  const blocks = doc.codeBlocks.filter((b) => b.lines.filter(([, line]) => line.trim()).length >= MIN_LINES);
   for (let later = 0; later < blocks.length; later++) {
     const current = blocks[later];
     const currentLines = current.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim());
@@ -38,7 +39,7 @@ export function run(doc, config) {
       const ratio = similarity(previous.lines.filter(([, line]) => line.trim()).map(([, line]) => line.trim()), currentLines);
       if (ratio >= config.duplicateBlockRatio) {
         findings.push(
-          finding(name, current.startLine, currentLines[0], `${previous.startLine}번째 줄의 블록과 ${Math.round(ratio * 100)}% 같다. 다른 줄만 남기거나 앞 블록을 가리킨다`, null, NOTICE, DOCUMENT, current.index),
+          finding(name, current.startLine, currentLines[0], `${previous.startLine}번째 줄의 블록과 ${roundHalfEven(ratio * 100, 0)}% 같다. 다른 줄만 남기거나 앞 블록을 가리킨다`, null, NOTICE, DOCUMENT, current.index),
         );
         break;
       }

package/src/rules/code/firstResultDistance.js

@@ -3,6 +3,7 @@ import { CODE, IMAGE, TABLE } from "../../document/model.js";
 import { NOTICE, PARAGRAPH, finding } from "../finding.js";
 
 export const name = "firstResultDistance";
+export const mechanism = "threshold";
 const RESULT_KINDS = [CODE, IMAGE, TABLE];
 
 /**