hanlint 0.0.7 → 0.0.9

package/src/rules/sentence/redundantPair.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "redundantPair";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/translationese.js

@@ -2,6 +2,7 @@
 import { dictionaryFindings } from "../shared/dictionaryRule.js";
 
 export const name = "translationese";
+export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/shared/candidates.js

@@ -0,0 +1,129 @@
+// @ts-check
+/** 파이썬 rules/shared/candidates.py의 투영. 후보에는 점수와 순위가 없다. */
+import { HAEYO, HANDA, HAPNIDA, REGISTERS, conjugate, fitJosa } from "../../analysis/grammar/index.js";
+import * as hangul from "../../analysis/grammar/hangul.js";
+import { decomposePassive } from "../../analysis/grammar/voice.js";
+import { stripJosa, words } from "../../analysis/tokenize.js";
+import { loadLines } from "../../data/load.js";
+
+const ENDING_CANDIDATES = {
+  [HAPNIDA]: [["-습니까?", "같은 문체의 의문형"], ["-기 때문입니다", "같은 문체의 인과형"]],
+  [HANDA]: [["-는가?", "같은 문체의 의문형"], ["-기 때문이다", "같은 문체의 인과형"]],
+  [HAEYO]: [["-나요?", "같은 문체의 의문형"], ["-기 때문이에요", "같은 문체의 인과형"]],
+};
+
+/** @param {string} text @returns {import("../finding.js").Candidate[]} */
+export function longSentenceCandidates(text) {
+  const endings = [...loadLines("candidateSplitEndings.txt")].sort((a, b) => b.length - a.length);
+  const pattern = new RegExp(`([가-힣]+(${endings.join("|")}))[,;]?\\s+`, "g");
+  const candidates = [];
+  for (const match of text.matchAll(pattern)) {
+    const word = match[1];
+    const ending = match[2];
+    if (word === "그리고" || word.length <= ending.length) continue;
+    const end = /** @type {number} */ (match.index) + match[0].length;
+    const marked = text.slice(0, end).trimEnd() + " | " + text.slice(end).trimStart();
+    candidates.push({ text: marked, why: `연결 어미 \`${ending}\` 뒤를 문장 경계로 검토한다` });
+  }
+  return candidates;
+}
+
+/** @param {string} topic @param {string} deixis */
+function replacementForDeixis(topic, deixis) {
+  if (deixis.startsWith("이것")) {
+    const suffix = deixis.slice("이것".length);
+    return topic + fitJosa(topic, suffix);
+  }
+  if (deixis.startsWith("해당 ")) {
+    const last = deixis.trim().split(/\s+/).at(-1) ?? "";
+    const base = stripJosa(last);
+    return topic + fitJosa(topic, last.slice(base.length));
+  }
+  if (deixis.startsWith("이러한 ")) return topic + "의 " + deixis.slice("이러한 ".length);
+  if (deixis === "이처럼") return topic + "처럼";
+  return topic;
+}
+
+/** @param {import("../../fingerprint/build.js").SentencePrint} current @param {import("../../fingerprint/build.js").SentencePrint | null} previous */
+export function danglingDeixisCandidates(current, previous) {
+  if (previous === null || !current.deixis.length) return [];
+  const deixis = current.deixis[0];
+  const topics = [...previous.topics].sort((a, b) => previous.text.toLowerCase().indexOf(a) - previous.text.toLowerCase().indexOf(b) || a.localeCompare(b));
+  return topics.map((topic) => ({
+    text: current.text.replace(deixis, replacementForDeixis(topic, deixis)),
+    why: `바로 앞 문장에 나온 명사 \`${topic}\``,
+  }));
+}
+
+/** @param {string} text */
+export function nounPileCandidates(text) {
+  const actionNouns = new Set(loadLines("candidateActionNouns.txt"));
+  const found = [];
+  for (const word of words(text)) {
+    const core = stripJosa(word.core);
+    if (actionNouns.has(core) && !found.includes(core)) found.push(core);
+  }
+  return found.map((noun) => ({ text: noun + "하다", why: `명사 \`${noun}\`${fitJosa(noun, "을")} 동사 어근으로 되돌린다` }));
+}
+
+/** @param {string} register */
+export function endingRepeatCandidates(register) {
+  const target = REGISTERS.includes(register) ? register : HAPNIDA;
+  return ENDING_CANDIDATES[target].map(([text, why]) => ({ text, why }));
+}
+
+/** @param {string} text @param {string} surface @param {string} reduced */
+function reducedPassiveText(text, surface, reduced) {
+  const prefix = surface.slice(0, -1);
+  let start = 0;
+  while ((start = text.indexOf(prefix, start)) >= 0) {
+    const tailAt = start + prefix.length;
+    const tail = text[tailAt];
+    if (!tail || !hangul.isSyllable(tail)) {
+      start += 1;
+      continue;
+    }
+    const [initial, vowel, final] = hangul.split(tail);
+    if (initial !== 12 || ![hangul.IH, hangul.YEO].includes(vowel)) {
+      start += 1;
+      continue;
+    }
+    let replacement;
+    if (vowel === hangul.YEO) {
+      const base = conjugate(reduced);
+      replacement = final ? base.slice(0, -1) + hangul.withFinal(base.at(-1), final) : base;
+    } else if (final === hangul.BIEUP) {
+      const polite = renderPolite(reduced);
+      replacement = polite.slice(0, -2);
+    } else {
+      replacement = final ? reduced.slice(0, -1) + hangul.withFinal(reduced.at(-1), final) : reduced;
+    }
+    return text.slice(0, start) + replacement + text.slice(tailAt + 1);
+  }
+  return null;
+}
+
+/** polite는 공개 함수가 아니므로 합니다체 활용에서 니다만 뗀다. @param {string} reduced */
+function renderPolite(reduced) {
+  const last = hangul.finalOf(reduced.at(-1));
+  if (last === hangul.NONE || last === hangul.RIEUL) {
+    const stem = last === hangul.RIEUL ? reduced.slice(0, -1) + hangul.withFinal(reduced.at(-1), hangul.NONE) : reduced;
+    return stem.slice(0, -1) + hangul.withFinal(stem.at(-1), hangul.BIEUP) + "니다";
+  }
+  return reduced + "습니다";
+}
+
+/** @param {string} text @param {string[]} passives */
+export function doublePassiveCandidates(text, passives) {
+  const candidates = [];
+  const seen = new Set();
+  for (const surface of passives) {
+    const voice = decomposePassive(surface);
+    if (!voice || voice.reduced === null) continue;
+    const candidateText = reducedPassiveText(text, surface, voice.reduced);
+    if (candidateText === null || seen.has(candidateText)) continue;
+    seen.add(candidateText);
+    candidates.push({ text: candidateText, why: `\`${surface}\`의 피동 겹을 하나로 줄인다` });
+  }
+  return candidates;
+}

package/src/rules/shared/dictionaryRule.js

@@ -1,5 +1,6 @@
 // @ts-check
 /** 사전 규칙의 공통 구현. cliche, translationese, redundantPair, japaneseLoan 이 사전 이름만 바꿔 쓴다. */
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { ERROR, SENTENCE, finding } from "../finding.js";
 
 /**
@@ -9,16 +10,25 @@ import { ERROR, SENTENCE, finding } from "../finding.js";
  * @param {string} [severity]
  * @returns {import("../finding.js").Finding[]}
  */
+/** 문장 시작부터 걸린 자리까지의 줄바꿈 수. 뜻은 파이썬 rules/shared/dictionaryRule.py 가 소유한다. @param {string} text */
+function countNewlines(text) {
+  let count = 0;
+  for (const ch of text) if (ch === "\n") count += 1;
+  return count;
+}
+
 export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR) {
   const findings = [];
   for (const sentence of doc.sentences) {
     for (const match of sentence.matches) {
       if (match.dictionary !== dictionary) continue;
-      const fix = match.fix !== null ? sentence.text.slice(0, match.start) + match.fix + sentence.text.slice(match.end) : null;
+      // 낱말만 갈아 끼우면 뒤에 붙은 조사가 틀어진다. `이슈로` 를 `쟁점로` 로 내밀던 자리다
+      const tail = sentence.text.slice(match.end);
+      const fix = match.fix !== null ? sentence.text.slice(0, match.start) + match.fix + fitJosa(match.fix, tail) : null;
       findings.push(
         finding(
           ruleName,
-          sentence.line,
+          sentence.line + countNewlines(sentence.text.slice(0, match.start)),
           sentence.text,
           `\`${match.text}\` ${match.why} (${match.source})`,
           fix,

package/src/rules/shared/localAntecedent.js

@@ -0,0 +1,12 @@
+// @ts-check
+import { overlap, topicsOf } from "../../fingerprint/topics.js";
+
+/** @param {import("../../fingerprint/build.js").SentencePrint} sentence */
+export function hasLocalAntecedent(sentence) {
+  const marker = sentence.deixis[0];
+  const start = sentence.text.indexOf(marker);
+  const before = start > 0 ? topicsOf(sentence.text.slice(0, start)) : new Set();
+  if (marker.startsWith("이것")) return before.size > 0;
+  if (marker.startsWith("해당 ") || marker.startsWith("이러한 ")) return overlap(before, topicsOf(marker)) > 0;
+  return false;
+}

package/src/rules/shared/repeat.js

@@ -0,0 +1,48 @@
+// @ts-check
+/**
+ * 반복 기제. 같은 모양이 창 안에서 이어지거나 (runsOf) 한 모양이 창을 채우는 (shareOf) 자리를 센다.
+ * 파이썬 rules/shared/repeat.py 와 같다. 규칙은 열쇠와 창과 임계만 선언하고 셈은 여기서 한다.
+ */
+
+/**
+ * 같은 값이 minLength 개 이상 이어지는 구간을 [시작 위치, 길이, 값] 으로 준다.
+ * @template T
+ * @param {T[]} values
+ * @param {number} minLength
+ * @returns {[number, number, T][]}
+ */
+export function runsOf(values, minLength) {
+  /** @type {[number, number, T][]} */
+  const runs = [];
+  let start = 0;
+  while (start < values.length) {
+    let end = start;
+    while (end + 1 < values.length && values[end + 1] === values[start]) end += 1;
+    const length = end - start + 1;
+    if (length >= minLength) runs.push([start, length, values[start]]);
+    start = end + 1;
+  }
+  return runs;
+}
+
+/**
+ * 가장 많은 값과 그 수와 전체 수. 같은 수면 먼저 나온 값이 이긴다. 빈 열이면 [null, 0, 0].
+ * @template T
+ * @param {T[]} values
+ * @returns {[T | null, number, number]}
+ */
+export function shareOf(values) {
+  /** @type {Map<T, number>} */
+  const counts = new Map();
+  for (const value of values) counts.set(value, (counts.get(value) ?? 0) + 1);
+  /** @type {T | null} */
+  let best = null;
+  let count = 0;
+  for (const [value, seen] of counts) {
+    if (seen > count) {
+      best = value;
+      count = seen;
+    }
+  }
+  return [best, count, values.length];
+}

package/src/rules/structure/blockUnread.js

@@ -0,0 +1,33 @@
+// @ts-check
+import { PROSE } from "../../document/model.js";
+import { NOTICE, SECTION, finding } from "../finding.js";
+
+export const name = "blockUnread";
+export const mechanism = "threshold";
+const OUTPUT_LANGUAGES = ["", "text", "output", "console"];
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  /** @type {Map<number, string>} */
+  const languages = new Map(doc.codeBlocks.map((block) => [block.index, block.language]));
+  const outputs = new Set([...languages].filter(([, language]) => OUTPUT_LANGUAGES.includes(language)).map(([index]) => index));
+  if (!outputs.size) return [];
+  const blocks = [...doc.blocks].sort((a, b) => a.index - b.index);
+  const findings = [];
+  for (let position = 0; position < blocks.length; position += 1) {
+    const block = blocks[position];
+    if (!outputs.has(block.index) || position === 0) continue;
+    const previous = languages.get(blocks[position - 1].index);
+    if (previous === undefined || OUTPUT_LANGUAGES.includes(previous)) continue;
+    const following = position + 1 < blocks.length ? blocks[position + 1] : null;
+    if (following !== null && following.kind === PROSE) continue;
+    findings.push(
+      finding(name, block.startLine, block.text.includes("\n") ? block.text.split("\n")[1] : block.text, "출력을 붙여 놓고 읽어 주지 않았다. 어느 부분이 무엇인지 짚는 문장을 바로 아래에 붙인다", null, NOTICE, SECTION, block.index),
+    );
+  }
+  return findings;
+}

package/src/rules/structure/bridgeRepeat.js

@@ -0,0 +1,40 @@
+// @ts-check
+import { matchedTexts } from "../../fingerprint/markers.js";
+import { DOCUMENT, finding } from "../finding.js";
+
+export const name = "bridgeRepeat";
+export const mechanism = "repeat";
+
+/**
+ * 절을 닫는 문장이 이음 표지 (이번에는, 이제, 다음으로) 로 시작하는 절이 bridgeRepeatMin 개 이상인 글.
+ * 파이썬 rules/structure/bridgeRepeat.py 와 같다. 표지 목록은 data/bridgeOpeners.txt.
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  /** @type {[import("../../fingerprint/build.js").SentencePrint, string][]} */
+  const closers = [];
+  for (const section of doc.bodySections) {
+    if (!section.paragraphs.length) continue;
+    const sentences = section.paragraphs[section.paragraphs.length - 1].sentences;
+    if (!sentences.length) continue;
+    const last = sentences[sentences.length - 1];
+    const found = matchedTexts(last.text, "bridgeOpeners.txt");
+    if (found.length) closers.push([last, found[0]]);
+  }
+  if (closers.length < config.bridgeRepeatMin) return [];
+  const markers = [...new Set(closers.map(([, marker]) => marker))].sort();
+  const [first] = closers[0];
+  return [
+    finding(
+      name,
+      first.line,
+      first.text,
+      `절 ${closers.length}개가 \`${markers.join(", ")}\` 같은 이음 표지로 시작하는 문장으로 닫힌다. 예고가 절마다 되풀이되면 틀이다. 방금 만든 결과를 이름으로 부르고 아직 못 하는 일을 적는다`,
+      null,
+      "error",
+      DOCUMENT,
+      -1,
+    ),
+  ];
+}

package/src/rules/structure/emojiBullet.js

@@ -3,6 +3,7 @@ import { LIST } from "../../document/model.js";
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "emojiBullet";
+export const mechanism = "dictionary";
 // 이모지 범위. 코드포인트로 만든다 (도구가 이스케이프를 건드리지 않게). 아스트랄 범위라 u 플래그가 필요하다.
 const EMOJI =
   "[" +

package/src/rules/structure/headingSentence.js

@@ -2,12 +2,17 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "headingSentence";
-const SENTENCE_ENDINGS = ["니다", "세요", "십시오", "합시다", "."];
+export const mechanism = "threshold";
+const SENTENCE_ENDINGS = ["니다", "한다", "해요", "세요", "십시오", "합시다", "."];
 
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
   const findings = [];
-  for (const [, text, line] of doc.headings) {
+  for (const [level, text, line] of doc.headings) {
+    if (level > config.headingSentenceMaxLevel) continue;
     const trimmed = text.trimEnd();
     if (SENTENCE_ENDINGS.some((ending) => trimmed.endsWith(ending))) {
       findings.push(finding(name, line, text, "절 제목이 본문 문장을 복사했다. 대상이나 질문을 짧게 쓴다", null, "error", DOCUMENT, -1));

package/src/rules/structure/headingSkip.js

@@ -2,6 +2,7 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "headingSkip";
+export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/structure/headingUniform.js

@@ -1,7 +1,9 @@
 // @ts-check
 import { DOCUMENT, finding } from "../finding.js";
+import { shareOf } from "../shared/repeat.js";
 
 export const name = "headingUniform";
+export const mechanism = "repeat";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
@@ -9,33 +11,23 @@ export const name = "headingUniform";
  */
 export function run(doc, config) {
   const headings = doc.headings.filter(([level]) => level === 2);
-  // 버전이나 날짜처럼 숫자로 끝나는 제목은 어미가 아니라 판정에서 뺀다.
+  // 어미는 한글이다. 숫자, 부호, 라틴 문자로 끝나는 제목은 판정에서 뺀다. 파이썬과 같다.
   const eligible = headings.filter(([, text]) => {
     if (!text.trim()) return false;
     const trimmed = text.trimEnd();
     const char = trimmed[trimmed.length - 1];
-    return !(char >= "0" && char <= "9");
+    return char >= "가" && char <= "힣";
   });
   if (eligible.length < 3) return [];
-  // 파이썬 Counter.most_common 은 같은 수면 먼저 들어온 것이 이긴다. 삽입 순서를 지킨다.
-  /** @type {Map<string, number>} */
-  const lastChars = new Map();
-  for (const [, text] of eligible) {
-    const trimmed = text.trimEnd();
-    const char = trimmed[trimmed.length - 1];
-    lastChars.set(char, (lastChars.get(char) ?? 0) + 1);
-  }
-  let best = "";
-  let count = -1;
-  for (const [char, n] of lastChars) {
-    if (n > count) {
-      best = char;
-      count = n;
-    }
-  }
-  if (count / eligible.length >= config.headingUniformRatio) {
+  const [best, count, total] = shareOf(
+    eligible.map(([, text]) => {
+      const trimmed = text.trimEnd();
+      return trimmed[trimmed.length - 1];
+    }),
+  );
+  if (count / total >= config.headingUniformRatio) {
     return [
-      finding(name, eligible[0][2], eligible.map(([, text]) => text).join(" / "), `H2 ${eligible.length}개 중 ${count}개가 \`${best}\` 로 끝난다. 목차가 한 어미로 끝나면 과정이 아니라 나열로 읽힌다. 형태를 섞는다`, null, "error", DOCUMENT, -1),
+      finding(name, eligible[0][2], eligible.map(([, text]) => text).join(" / "), `H2 ${eligible.length}개 중 ${count}개가 \`${best}\` 로 끝난다. 목차가 한 어미로 끝나면 과정이 아니라 나열로 읽힌다. 그 문서의 관례라면 둔다`, null, "notice", DOCUMENT, -1),
     ];
   }
   return [];

package/src/rules/structure/introImage.js

@@ -0,0 +1,19 @@
+// @ts-check
+import { IMAGE } from "../../document/model.js";
+import { SECTION, finding } from "../finding.js";
+
+export const name = "introImage";
+export const mechanism = "threshold";
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  if (!doc.bodySections.length) return [];
+  const count = doc.intro.blockKinds.filter((kind) => kind === IMAGE).length;
+  if (count <= config.introMaxImages) return [];
+  return [
+    finding(name, doc.intro.startLine, doc.intro.title || "도입", `도입에 그림이 ${count}장이다. ${config.introMaxImages}장을 넘지 않는다. 나머지는 그것을 설명하는 절로 내린다`, null, "error", SECTION, doc.intro.index),
+  ];
+}

package/src/rules/structure/introLong.js

@@ -2,14 +2,17 @@
 import { PARAGRAPH, finding } from "../finding.js";
 
 export const name = "introLong";
+export const mechanism = "threshold";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
  * @param {import("../../config/settings.js").Config} config
  */
 export function run(doc, config) {
-  if (!doc.bodySections.length) return [];
+  // 본문 절이 하나뿐이거나 도입이 문단의 절반을 넘으면 절이 없는 글이지 도입이 긴 글이 아니다. 파이썬과 같다.
+  if (doc.bodySections.length < 2) return [];
   const paragraphs = doc.intro.paragraphs;
+  if (paragraphs.length * 2 > doc.paragraphs.length) return [];
   if (paragraphs.length > config.introMaxParagraphs) {
     const over = paragraphs[config.introMaxParagraphs];
     return [

package/src/rules/structure/loneSubheading.js

@@ -0,0 +1,42 @@
+// @ts-check
+import { topicsOf } from "../../fingerprint/topics.js";
+import { NOTICE, SECTION, finding } from "../finding.js";
+
+export const name = "loneSubheading";
+export const mechanism = "contrast";
+
+/** (부모 H2 제목, 외동 H3 제목, 그 줄). H2 하나 아래 H3 이 정확히 하나일 때만. @param {[number, string, number][]} headings */
+function onlyChild(headings) {
+  /** @type {[string, string, number][]} */
+  const found = [];
+  for (let position = 0; position < headings.length; position += 1) {
+    const [level, text] = headings[position];
+    if (level !== 2) continue;
+    /** @type {[string, number][]} */
+    const children = [];
+    for (const [childLevel, childText, childLine] of headings.slice(position + 1)) {
+      if (childLevel <= 2) break;
+      if (childLevel === 3) children.push([childText, childLine]);
+    }
+    if (children.length === 1) found.push([text, children[0][0], children[0][1]]);
+  }
+  return found;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  const findings = [];
+  for (const [parent, child, line] of onlyChild(doc.headings)) {
+    const childTopics = topicsOf(child);
+    const parentTopics = topicsOf(parent);
+    if (!childTopics.size || ![...childTopics].every((word) => parentTopics.has(word))) continue;
+    findings.push(
+      finding(name, line, child, `\`${parent}\` 아래 소제목이 이것 하나뿐이고 절 제목에 없는 말이 하나도 없다. 소제목을 지우고 본문을 올린다`, null, NOTICE, SECTION, -1),
+    );
+  }
+  return findings;
+}

package/src/rules/structure/moreLater.js

@@ -0,0 +1,48 @@
+// @ts-check
+import { LIST } from "../../document/model.js";
+import { plainText } from "../../document/plainText.js";
+import { NOTICE, SECTION, finding } from "../finding.js";
+
+export const name = "moreLater";
+export const mechanism = "threshold";
+const BULLET = /^\s*(?:[-*+]|\d+[.)])\s+/;
+
+/** (블록 안 줄 오프셋, 항목 전체). 이어지는 줄은 앞 항목에 붙인다. @param {string} text @returns {[number, string][]} */
+function itemsOf(text) {
+  /** @type {[number, string][]} */
+  const items = [];
+  text.split("\n").forEach((line, offset) => {
+    if (BULLET.test(line)) {
+      items.push([offset, line.replace(BULLET, "").trim()]);
+    } else if (items.length && line.trim()) {
+      const last = items[items.length - 1];
+      last[1] = `${last[1]} ${line.trim()}`;
+    }
+  });
+  return items;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  if (doc.sections.length < 2) return [];
+  const last = doc.sections[doc.sections.length - 1];
+  if (last.isIntro) return [];
+  /** @type {[number, string][]} */
+  const over = [];
+  for (const block of doc.blocks) {
+    if (block.kind !== LIST || block.startLine < last.startLine) continue;
+    for (const [offset, item] of itemsOf(block.text)) {
+      const visible = plainText(item);
+      if (visible.length > config.moreLaterMaxChars) over.push([block.startLine + offset, visible]);
+    }
+  }
+  if (!over.length) return [];
+  let best = over[0];
+  for (const pair of over) if (pair[1].length > best[1].length) best = pair;
+  return [
+    finding(name, best[0], best[1], `마지막 절의 목록 항목 ${over.length}개가 ${config.moreLaterMaxChars}자를 넘는다 (가장 긴 것 ${best[1].length}자). 미룬 것이 아니라 옮겨 적은 것이다. 한 줄과 링크로 줄인다`, null, NOTICE, SECTION, last.index),
+  ];
+}

package/src/rules/structure/sectionNoProse.js

@@ -3,6 +3,7 @@ import { LIST, PROSE } from "../../document/model.js";
 import { SECTION, finding } from "../finding.js";
 
 export const name = "sectionNoProse";
+export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/text.js

@@ -61,3 +61,22 @@ export function countIn(text, needle, end = text.length) {
     from = at + needle.length;
   }
 }
+
+/**
+ * 파이썬 round(value, digits). 정확한 이진 값을 십진으로 풀어 반올림하고 정확히 절반이면 짝수로 간다.
+ * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 판의 글자가 같으려면 파이썬 쪽이다.
+ * toFixed(100) 은 1e21 아래의 수를 정확한 십진 전개로 준다. 지문의 비율과 평균이 사는 범위다.
+ * @param {number} value
+ * @param {number} digits
+ */
+export function roundHalfEven(value, digits) {
+  if (!Number.isFinite(value) || Math.abs(value) >= 1e21) return value;
+  const sign = value < 0 ? -1 : 1;
+  const [whole, fraction] = Math.abs(value).toFixed(100).split(".");
+  const rest = fraction.slice(digits);
+  let units = BigInt(whole + fraction.slice(0, digits));
+  const next = rest.charCodeAt(0) - 48;
+  const halfway = next === 5 && /^0*$/.test(rest.slice(1));
+  if (next > 5 || (next === 5 && !halfway) || (halfway && units % 2n === 1n)) units += 1n;
+  return sign * (Number(units) / 10 ** digits);
+}

package/data/coverageTypes.txt

@@ -1,7 +0,0 @@
-# 사람 평가자의 지적을 유형으로 가르는 표지. `유형<TAB>정규식`. coverage 가 못 집은 지적을 모을 때 쓴다. 위에서부터 먼저 맞는 것이 이긴다.
-파일과 폴더	파일|폴더|경로|만들어지지|생성|없어서|없다
-설치와 실행	설치|import|모듈|패키지|실행|오류|에러|Error|멈춘다|돌아가지
-순서와 구조	순서|먼저|앞에서|뒤에서|절|목차|위치|옮|건너
-용어와 설명	설명|뜻|처음 나온|용어|무엇인지|모른|정의
-숫자와 표	숫자|표|열|행|값|측정|잰
-문장과 표현	문장|주어|서술어|표현|반복|같은 말|어색

package/src/rules/document/readerAbsent.js

@@ -1,11 +0,0 @@
-// @ts-check
-import { DOCUMENT, NOTICE, finding } from "../finding.js";
-
-export const name = "readerAbsent";
-
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  if (doc.bodySections.length < 2 || doc.questionCount > 0 || doc.readerCallCount > 0) return [];
-  const first = doc.sentences.length ? doc.sentences[0] : null;
-  return [finding(name, first ? first.line : 1, first ? first.text : "", "질문도 독자를 부르는 문장도 없다. 독자가 할 행동을 동사로 끝내는 문장을 한 번은 넣는다", null, NOTICE, DOCUMENT, -1)];
-}

package/src/rules/paragraph/topicBreak.js

@@ -1,25 +0,0 @@
-// @ts-check
-import { NOTICE, PARAGRAPH, finding } from "../finding.js";
-
-export const name = "topicBreak";
-
-/**
- * @param {import("../../fingerprint/build.js").DocumentPrint} doc
- * @param {import("../../config/settings.js").Config} config
- */
-export function run(doc, config) {
-  const findings = [];
-  for (const section of doc.sections) {
-    const paragraphs = section.paragraphs;
-    for (let i = 0; i + 1 < paragraphs.length; i++) {
-      const previous = paragraphs[i];
-      const paragraph = paragraphs[i + 1];
-      if (paragraph.overlapWithPrevious !== 0) continue;
-      if (Math.min(previous.sentenceCount, paragraph.sentenceCount) < config.topicBreakMinSentences) continue;
-      findings.push(
-        finding(name, paragraph.startLine, paragraph.sentences[0].text, "앞 문단과 화제어가 하나도 겹치지 않는다. 앞에서 만든 것의 이름을 첫 문장에서 다시 부른다", null, NOTICE, PARAGRAPH, paragraph.index),
-      );
-    }
-  }
-  return findings;
-}

package/src/rules/sentence/ellipsis.js

@@ -1,18 +0,0 @@
-// @ts-check
-import { SENTENCE, finding } from "../finding.js";
-
-export const name = "ellipsis";
-// 괄호 안의 점 셋 (`OVER (...)`) 은 인라인 코드의 생략 표기라 뺀다.
-// 영숫자에 붙은 점 셋 (`v0.0.1...HEAD`, compare URL) 은 범위 표기라 말줄임표가 아니다.
-const ELLIPSIS = /(?<![(\[A-Za-z0-9])(…|\.{3,})(?![)\]A-Za-z0-9])/;
-
-/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
-export function run(doc) {
-  const findings = [];
-  for (const sentence of doc.sentences) {
-    if (ELLIPSIS.test(sentence.text)) {
-      findings.push(finding(name, sentence.line, sentence.text, "말줄임표로 말끝을 흐리면 독자가 결론을 받아 가지 못한다. 문장을 끝까지 쓴다", null, "error", SENTENCE, sentence.index));
-    }
-  }
-  return findings;
-}