hanlint 0.0.7 → 0.0.9

package/src/rules/registry.js

@@ -5,12 +5,15 @@
  * 기술서 (왜, 어디서, 고치기, 안 잡는 것) 는 파이썬 docstring 의 투영 data/ruleDocs.json 에서 읽는다.
  */
 import { enabled } from "../config/settings.js";
-import { loadRuleDocs } from "../data/load.js";
+import { loadRuleCategories, loadRuleDocs } from "../data/load.js";
 import * as countMismatch from "./document/countMismatch.js";
+import * as enoughOnce from "./document/enoughOnce.js";
+import * as fieldEcho from "./document/fieldEcho.js";
+import * as keywordHeading from "./document/keywordHeading.js";
 import * as keywordMissing from "./document/keywordMissing.js";
 import * as noQuestion from "./document/noQuestion.js";
 import * as promiseRecall from "./document/promiseRecall.js";
-import * as readerAbsent from "./document/readerAbsent.js";
+import * as tableOddCell from "./document/tableOddCell.js";
 import * as duplicateBlock from "./code/duplicateBlock.js";
 import * as firstResultDistance from "./code/firstResultDistance.js";
 import * as inputFileSource from "./code/inputFileSource.js";
@@ -21,16 +24,16 @@ import * as spacing from "./orthography/spacing.js";
 import * as spelling from "./orthography/spelling.js";
 import * as factListParagraph from "./paragraph/factListParagraph.js";
 import * as paraFragment from "./paragraph/paraFragment.js";
-import * as topicBreak from "./paragraph/topicBreak.js";
 import * as cliche from "./sentence/cliche.js";
 import * as hardWord from "./sentence/hardWord.js";
 import * as connectorRepeat from "./sentence/connectorRepeat.js";
 import * as danglingDeixis from "./sentence/danglingDeixis.js";
+import * as draftHistory from "./sentence/draftHistory.js";
+import * as numberOrphan from "./sentence/numberOrphan.js";
 import * as dash from "./sentence/dash.js";
 import * as deixis from "./sentence/deixis.js";
 import * as doubleNegative from "./sentence/doubleNegative.js";
 import * as doublePassive from "./sentence/doublePassive.js";
-import * as ellipsis from "./sentence/ellipsis.js";
 import * as endingRepeat from "./sentence/endingRepeat.js";
 import * as euiChain from "./sentence/euiChain.js";
 import * as fillerOpener from "./sentence/fillerOpener.js";
@@ -39,19 +42,25 @@ import * as japaneseLoan from "./sentence/japaneseLoan.js";
 import * as longSentence from "./sentence/longSentence.js";
 import * as negationRedefine from "./sentence/negationRedefine.js";
 import * as nounPile from "./sentence/nounPile.js";
+import * as outsideProfile from "./sentence/outsideProfile.js";
 import * as redundantPair from "./sentence/redundantPair.js";
 import * as translationese from "./sentence/translationese.js";
+import * as blockUnread from "./structure/blockUnread.js";
+import * as bridgeRepeat from "./structure/bridgeRepeat.js";
 import * as emojiBullet from "./structure/emojiBullet.js";
+import * as introImage from "./structure/introImage.js";
+import * as loneSubheading from "./structure/loneSubheading.js";
+import * as moreLater from "./structure/moreLater.js";
 import * as headingSentence from "./structure/headingSentence.js";
 import * as headingSkip from "./structure/headingSkip.js";
 import * as headingUniform from "./structure/headingUniform.js";
 import * as introLong from "./structure/introLong.js";
 import * as sectionNoProse from "./structure/sectionNoProse.js";
-import * as sectionResult from "./structure/sectionResult.js";
 
 /**
  * @typedef {object} Rule
  * @property {string} name
+ * @property {string} mechanism 세는 방법. MECHANISMS 의 키 하나
  * @property {(doc: import("../fingerprint/build.js").DocumentPrint, config: import("../config/settings.js").Config) => import("./finding.js").Finding[]} run
  */
 
@@ -61,10 +70,11 @@ export const RULES = [
   connectorRepeat,
   danglingDeixis,
   dash,
+  draftHistory,
+  numberOrphan,
   deixis,
   doubleNegative,
   doublePassive,
-  ellipsis,
   endingRepeat,
   euiChain,
   fillerOpener,
@@ -74,23 +84,30 @@ export const RULES = [
   longSentence,
   negationRedefine,
   nounPile,
+  outsideProfile,
   redundantPair,
   translationese,
   factListParagraph,
   paraFragment,
-  topicBreak,
+  blockUnread,
+  bridgeRepeat,
   emojiBullet,
+  introImage,
+  loneSubheading,
+  moreLater,
   headingSentence,
   headingSkip,
   headingUniform,
   introLong,
   sectionNoProse,
-  sectionResult,
   countMismatch,
+  enoughOnce,
+  fieldEcho,
+  tableOddCell,
+  keywordHeading,
   keywordMissing,
   noQuestion,
   promiseRecall,
-  readerAbsent,
   spelling,
   spacing,
   confusable,
@@ -101,6 +118,23 @@ export const RULES = [
   platformApi,
 ];
 
+/**
+ * 규칙이 세는 방법의 닫힌 집합. 파이썬 rules/registry.py 의 MECHANISMS 와 같은 값과 같은 순서다.
+ * @type {Record<string, string>}
+ */
+export const MECHANISMS = {
+  dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
+  repeat: "반복. 같은 모양이 창 안에서 N 번",
+  threshold: "셈. 지문의 값이 임계를 넘거나 모양이 계약과 다른 자리",
+  contrast: "대조. 두 자리를 맞대 어긋난 곳",
+  reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
+};
+for (const rule of RULES) {
+  if (!(rule.mechanism in MECHANISMS)) {
+    throw new Error(`규칙 ${rule.name} 의 기제 ${rule.mechanism} 은 닫힌 집합 밖이다 (${Object.keys(MECHANISMS).join(", ")}). 새 기제는 규칙 하나 때문에 들어오지 않는다. 멈춰서 묻는다`);
+  }
+}
+
 const BY_NAME = new Map(RULES.map((rule) => [rule.name, rule]));
 
 /** 이름 순. */
@@ -120,6 +154,33 @@ export function ruleSummary(name) {
   return ruleDoc(name).split("\n")[0];
 }
 
+/**
+ * 부류의 사람 이름. 파이썬 rules/registry.py 의 CATEGORY_TITLES 와 같은 값과 같은 순서다.
+ * @type {Record<string, string>}
+ */
+export const CATEGORY_TITLES = {
+  sentence: "문장 안에서 세는 것",
+  paragraph: "문단 사이에서 세는 것",
+  structure: "글의 짜임에서 세는 것",
+  document: "두 자리를 대조해 세는 것",
+  orthography: "표기와 띄어쓰기",
+  code: "코드 블록 사이를 대조하는 것",
+};
+
+/** 규칙이 세는 방법. @param {string} name */
+export function ruleMechanism(name) {
+  const rule = BY_NAME.get(name);
+  if (!rule) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  return rule.mechanism;
+}
+
+/** 규칙이 사는 부류. 정본은 파이썬 쪽 폴더이고 여기는 그 투영을 읽는다. @param {string} name */
+export function ruleCategory(name) {
+  const categories = loadRuleCategories();
+  if (!(name in categories)) throw new Error(`모르는 규칙: ${name}. hanlint rules 로 목록을 본다`);
+  return categories[name];
+}
+
 /**
  * 인라인 제어가 그 줄에서 그 규칙을 껐는가. `*` 는 전부다.
  * @param {import("./finding.js").Finding} f

package/src/rules/sentence/cliche.js

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

package/src/rules/sentence/connectorRepeat.js

@@ -1,22 +1,23 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { runsOf } from "../shared/repeat.js";
 
 export const name = "connectorRepeat";
+export const mechanism = "repeat";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const paragraph of doc.paragraphs) {
-    /** @type {string | null} */
-    let previous = null;
-    for (const sentence of paragraph.sentences) {
-      const current = sentence.connectorStart;
-      if (current && current === previous) {
+    const sentences = paragraph.sentences;
+    // 열쇠는 문두 접속부사다. 접속부사가 없는 문장은 저마다 다른 열쇠를 받아 구간을 끊는다.
+    const keys = sentences.map((sentence) => sentence.connectorStart || `__${sentence.index}`);
+    for (const [start, length, connector] of runsOf(keys, 2)) {
+      for (const sentence of sentences.slice(start + 1, start + length)) {
         findings.push(
-          finding(name, sentence.line, sentence.text, `\`${current}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
+          finding(name, sentence.line, sentence.text, `\`${connector}\` 로 시작하는 문장이 연달아 온다. 앞에서 만든 것의 이름을 불러 잇는다`, null, "error", SENTENCE, sentence.index),
         );
       }
-      previous = current;
     }
   }
   return findings;

package/src/rules/sentence/danglingDeixis.js

@@ -1,18 +1,38 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { overlap } from "../../fingerprint/topics.js";
 import { SENTENCE, finding } from "../finding.js";
+import { danglingDeixisCandidates } from "../shared/candidates.js";
+import { hasLocalAntecedent } from "../shared/localAntecedent.js";
 
 export const name = "danglingDeixis";
+export const mechanism = "reader";
+
+const QUESTION = "의문";
+const EXCLAIM = ["!", "！"];
+
+/**
+ * 앞 문장이 물음이나 감탄인가. 그러면 그 문장 자체가 지시어의 선행어다.
+ * 뜻은 파이썬 rules/sentence/danglingDeixis.py 의 isPrompt 가 소유한다.
+ * @param {{mood: string, text: string} | null} previous
+ */
+function isPrompt(previous) {
+  if (!previous) return false;
+  const text = previous.text.replace(/\s+$/u, "");
+  return previous.mood === QUESTION || EXCLAIM.some((mark) => text.endsWith(mark));
+}
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (!sentence.deixis.length) continue;
-    const previous = sentence.index > 0 ? doc.sentences[sentence.index - 1] : null;
-    if (previous !== null && overlap(previous.topics, sentence.topics) > 0) continue;
+    if (hasLocalAntecedent(sentence)) continue;
+    const reader = doc.reader.beforeSentence[sentence.index];
+    if (overlap(reader.recent, sentence.topics) > 0) continue;
+    if (isPrompt(reader.previous)) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` 이 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "이")} 가리킬 것이 앞 문장에 없다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index, null, null, danglingDeixisCandidates(sentence, reader.previous)),
     );
   }
   return findings;

package/src/rules/sentence/dash.js

@@ -2,13 +2,14 @@
 import { DOCUMENT, finding } from "../finding.js";
 
 export const name = "dash";
+export const mechanism = "dictionary";
 // 리터럴로 쓰면 이 파일이 자기 게이트에 걸린다. 코드포인트로 만든다.
 const DASHES = new RegExp(`[${String.fromCharCode(0x2013)}${String.fromCharCode(0x2014)}]`);
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
-  for (const block of doc.blocks) {
+  for (const block of [...doc.blocks, ...doc.ignored]) {
     block.text.split("\n").forEach((lineText, offset) => {
       if (DASHES.test(lineText)) {
         findings.push(

package/src/rules/sentence/deixis.js

@@ -1,18 +1,22 @@
 // @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
 import { overlap } from "../../fingerprint/topics.js";
 import { SENTENCE, finding } from "../finding.js";
+import { hasLocalAntecedent } from "../shared/localAntecedent.js";
 
 export const name = "deixis";
+export const mechanism = "reader";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (!sentence.deixis.length || sentence.index === 0) continue;
-    const previous = doc.sentences[sentence.index - 1];
-    if (overlap(previous.topics, sentence.topics) === 0) continue;
+    if (hasLocalAntecedent(sentence)) continue;
+    const reader = doc.reader.beforeSentence[sentence.index];
+    if (overlap(reader.recent, sentence.topics) === 0) continue;
     findings.push(
-      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` 은 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
+      finding(name, sentence.line, sentence.text, `\`${sentence.deixis[0]}\` ${fitJosa(sentence.deixis[0], "은")} 독자가 스크롤을 되돌려야 하는 지시어다. 가리키는 파일, 값, 코드의 이름을 쓴다`, null, "error", SENTENCE, sentence.index),
     );
   }
   return findings;

package/src/rules/sentence/doubleNegative.js

@@ -2,13 +2,16 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "doubleNegative";
-const DOUBLE_NEGATIVE = /(하지 않으면 안 (?:된다|됩니다)|하지 않을 수 없(?:다|습니다)|지 않으면 안 (?:된다|됩니다)|지 않을 수 없(?:다|습니다))/;
+export const mechanism = "dictionary";
+const DOUBLE_NEGATIVE = /(하지 않으면 안 (?:된다|됩니다|돼요)|하지 않을 수 없(?:다|습니다|어요)|지 않으면 안 (?:된다|됩니다|돼요)|지 않을 수 없(?:다|습니다|어요))/;
 /** @type {Record<string, string>} */
 const FIXES = {
   "하지 않으면 안 된다": "해야 한다",
   "하지 않으면 안 됩니다": "해야 합니다",
   "하지 않을 수 없다": "한다",
   "하지 않을 수 없습니다": "합니다",
+  "하지 않으면 안 돼요": "해야 해요",
+  "하지 않을 수 없어요": "해요",
 };
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */

package/src/rules/sentence/doublePassive.js

@@ -1,15 +1,52 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { doublePassiveCandidates } from "../shared/candidates.js";
 
 export const name = "doublePassive";
+export const mechanism = "dictionary";
+
+/** 검토를 통과한 이중 피동 후보에서 인용 밖의 단일 치환만 꺼낸다.
+ * @param {string} text @param {string} candidateText @param {[number, number][]} quoted
+ * @returns {[string, string] | null} */
+function approvedEdit(text, candidateText, quoted) {
+  let prefix = 0;
+  while (prefix < text.length && prefix < candidateText.length && text[prefix] === candidateText[prefix]) prefix += 1;
+  let suffix = 0;
+  while (
+    suffix < text.length - prefix &&
+    suffix < candidateText.length - prefix &&
+    text[text.length - suffix - 1] === candidateText[candidateText.length - suffix - 1]
+  ) suffix += 1;
+  const sourceEnd = text.length - suffix;
+  const candidateEnd = candidateText.length - suffix;
+  const fragment = text.slice(prefix, sourceEnd);
+  const replacement = candidateText.slice(prefix, candidateEnd);
+  if (!fragment || text.indexOf(fragment) !== text.lastIndexOf(fragment)) return null;
+  if (quoted.some(([start, end]) => prefix < end && sourceEnd > start)) return null;
+  return [fragment, replacement];
+}
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
     if (sentence.passives.length) {
+      const candidates = doublePassiveCandidates(sentence.text, sentence.passives);
+      const approved = candidates.length === 1 ? approvedEdit(sentence.text, candidates[0].text, sentence.quoted) : null;
       findings.push(
-        finding(name, sentence.line, sentence.text, `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`, null, "error", SENTENCE, sentence.index),
+        finding(
+          name,
+          sentence.line,
+          sentence.text,
+          `\`${sentence.passives[0]}\` 는 피동에 어지다 를 또 붙인 이중 피동이다. 하나만 남긴다`,
+          approved ? candidates[0].text : null,
+          "error",
+          SENTENCE,
+          sentence.index,
+          approved ? approved[0] : null,
+          approved ? approved[1] : null,
+          approved ? [] : candidates,
+        ),
       );
     }
   }

package/src/rules/sentence/draftHistory.js

@@ -0,0 +1,24 @@
+// @ts-check
+import { insideAny, matchedSpans } from "../../fingerprint/markers.js";
+import { SENTENCE, finding } from "../finding.js";
+
+export const name = "draftHistory";
+export const mechanism = "dictionary";
+
+/**
+ * @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 sentence of doc.sentences) {
+    for (const [start, end, text] of matchedSpans(sentence.text, "draftHistory.txt")) {
+      if (insideAny(start, end, sentence.quoted)) continue;
+      findings.push(
+        finding(name, sentence.line, sentence.text, `\`${text}\` 는 글쓴이의 과정이다. 독자는 초고를 본 적이 없다. 알아낸 사실만 결과 문장으로 남긴다`, null, "error", SENTENCE, sentence.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/endingRepeat.js

@@ -1,8 +1,9 @@
 // @ts-check
 import { NOTICE, SENTENCE, finding } from "../finding.js";
-import { runsOf } from "../shared/runs.js";
+import { runsOf } from "../shared/repeat.js";
 
 export const name = "endingRepeat";
+export const mechanism = "repeat";
 const COUNTED_ENDINGS = new Set(["니다", "다", "것이다", "요", "죠"]);
 
 /**
@@ -15,9 +16,12 @@ export function run(doc, config) {
     const sentences = section.paragraphs.flatMap((p) => p.sentences);
     const endings = sentences.map((s) => (COUNTED_ENDINGS.has(s.ending) ? s.ending : `__${s.index}`));
     for (const [start, length, ending] of runsOf(endings, config.endingRun)) {
+      // 구간 어딘가에 이유를 잇는 말이나 독자를 부르는 말이 있으면 리듬이 산 것이다. 구간을 쪼개면
+      // 조각마다 지적이 되어 오히려 늘어난다. 구간 전체를 하나로 보고 살린다.
+      if (sentences.slice(start, start + length).some((s) => s.causal || s.readerCall)) continue;
       const first = sentences[start];
       findings.push(
-        finding(name, first.line, first.text, `\`${ending}\` 로 끝나는 문장이 ${length}개 이어진다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
+        finding(name, first.line, first.text, `\`${ending}\` 로 끝나는 문장 ${length}개에 인과도 질문도 독자를 부르는 말도 없다. 질문, 인과, 행동 동사로 리듬을 바꾼다`, null, NOTICE, SENTENCE, first.index),
       );
     }
   }

package/src/rules/sentence/euiChain.js

@@ -1,14 +1,15 @@
 // @ts-check
+import { euiAdjacent } from "../../analysis/index.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "euiChain";
-const ADJACENT = /[가-힣]+의\s+[가-힣]+의(?=[\s,.)\]]|$)/;
+export const mechanism = "threshold";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
   for (const sentence of doc.sentences) {
-    if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && ADJACENT.test(sentence.text))) {
+    if (sentence.euiCount >= 3 || (sentence.euiCount >= 2 && euiAdjacent(sentence.text))) {
       findings.push(
         finding(name, sentence.line, sentence.text, `한 문장에 \`의\` 가 ${sentence.euiCount}번이다. 명사를 쌓은 자리라 관계가 표시되지 않는다. 동사로 편다`, null, "error", SENTENCE, sentence.index),
       );

package/src/rules/sentence/fillerOpener.js

@@ -2,6 +2,7 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "fillerOpener";
+export const mechanism = "dictionary";
 const FILLER = /^(다음으로|이어서|마지막에는|마지막으로)(?=[\s,])/;
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */

package/src/rules/sentence/hardWord.js

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

package/src/rules/sentence/imperativePeriod.js

@@ -2,7 +2,8 @@
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "imperativePeriod";
-const IMPERATIVE_PERIOD = /(세요|십시오|합시다|봅시다|하자|해라)\.(?=\s|$)/;
+export const mechanism = "dictionary";
+const IMPERATIVE_PERIOD = /(세요|십시오|합시다|봅시다|하자|해라|라)\.(?=\s|$)/;
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {

package/src/rules/sentence/japaneseLoan.js

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

package/src/rules/sentence/longSentence.js

@@ -1,7 +1,9 @@
 // @ts-check
 import { NOTICE, SENTENCE, finding } from "../finding.js";
+import { longSentenceCandidates } from "../shared/candidates.js";
 
 export const name = "longSentence";
+export const mechanism = "threshold";
 
 /**
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
@@ -12,7 +14,7 @@ export function run(doc, config) {
   for (const sentence of doc.sentences) {
     if (sentence.length > config.longSentenceMax) {
       findings.push(
-        finding(name, sentence.line, sentence.text, `어절 ${sentence.length}개다. 상한은 ${config.longSentenceMax}. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index),
+        finding(name, sentence.line, sentence.text, `어절 ${sentence.length}개다. 상한은 ${config.longSentenceMax}. 마침표로 끊거나 나열이면 목록으로 꺼낸다`, null, NOTICE, SENTENCE, sentence.index, null, null, longSentenceCandidates(sentence.text)),
       );
     }
   }

package/src/rules/sentence/negationRedefine.js

@@ -1,10 +1,20 @@
 // @ts-check
 import { SENTENCE, finding } from "../finding.js";
+import { COPULA as COPULA_KIND, lastWord, parsePredicate } from "../../analysis/grammar/index.js";
 
 export const name = "negationRedefine";
-const NEGATION = /단순(?:한|히)\s?.{0,15}?(?:이|가)\s?아(?:닙니다|니다|니에요|니죠|닌)/;
+export const mechanism = "repeat";
+// 관형형 `아닌` 은 뺐다. 문장을 끝낼 수 없어 앞 문장이 부정이라는 전제를 못 만족한다. 파이썬과 같다.
+const NEGATION = /단순(?:한|히)\s?.{0,15}?(?:이|가)\s?아(?:닙니다|니다|니에요|니죠)/;
 const COPULA = /(입니다|이다|이에요|예요)[.!]?$/;
 
+/** @param {string} text */
+function isDefinition(text) {
+  if (COPULA.test(text.trim())) return true;
+  const predicate = parsePredicate(lastWord(text));
+  return predicate !== null && predicate.kind === COPULA_KIND;
+}
+
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
   const findings = [];
@@ -13,7 +23,7 @@ export function run(doc) {
     for (let i = 0; i + 1 < sentences.length; i++) {
       const current = sentences[i];
       const following = sentences[i + 1];
-      if (NEGATION.test(current.text) && COPULA.test(following.text.trim())) {
+      if (NEGATION.test(current.text) && isDefinition(following.text)) {
         findings.push(finding(name, current.line, current.text, "단순한 X 가 아닙니다 뒤에 Y 입니다 로 재정의하는 공식이다. 앞 문장을 지우고 Y 를 바로 쓴다", null, "error", SENTENCE, current.index));
       }
     }

package/src/rules/sentence/nounPile.js

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

package/src/rules/sentence/numberOrphan.js

@@ -0,0 +1,45 @@
+// @ts-check
+import { fitJosa } from "../../analysis/grammar/josa.js";
+import { matchedTexts, numeralsIn } from "../../fingerprint/markers.js";
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+
+export const name = "numberOrphan";
+export const mechanism = "reader";
+const RANGE = /(\d[\d,]*(?:\.\d+)?)[^\s.!?]{0,4}\s?에서\s?(\d[\d,]*(?:\.\d+)?)[^\s.!?]{0,4}\s?(?:로|으로)/g;
+/** 한 자리 수는 재는 값이 아니라 세는 말이라 뺀다. */
+const MIN_DIGITS = 2;
+/** 기준값 앞 몇 글자에서 출처를 밝히는 말을 찾는가. */
+const ANCHOR_WINDOW = 12;
+
+/** @param {string} numeral */
+function isMeasured(numeral) {
+  return numeral.includes(".") || numeral.replaceAll(".", "").length >= MIN_DIGITS;
+}
+
+/** 값 바로 앞이 그 값이 어디서 온 것인지 말하고 있는가. @param {string} text @param {number} start */
+function isAnchored(text, start) {
+  return matchedTexts(text.slice(Math.max(0, start - ANCHOR_WINDOW), start), "baselineAnchors.txt").length > 0;
+}
+
+/**
+ * @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 sentence of doc.sentences) {
+    const reader = doc.reader.beforeSentence[sentence.index];
+    for (const match of sentence.text.matchAll(RANGE)) {
+      const base = match[1].replaceAll(",", "");
+      if (!isMeasured(base) || base === match[2].replaceAll(",", "")) continue;
+      const start = /** @type {number} */ (match.index);
+      if (reader.numerals.has(base) || numeralsIn(sentence.text.slice(0, start)).has(base)) continue;
+      if (isAnchored(sentence.text, start)) continue;
+      findings.push(
+        finding(name, sentence.line, sentence.text, `\`${base}\` ${fitJosa(base, "가")} 여기서 처음 나오는 값이다. 무엇에서 올라간 것인지 알 수 없다. 그 값이 어디서 나왔는지 밝힌다`, null, NOTICE, SENTENCE, sentence.index),
+      );
+    }
+  }
+  return findings;
+}

package/src/rules/sentence/outsideProfile.js

@@ -0,0 +1,68 @@
+// @ts-check
+import { PROFILE_OF } from "../../config/settings.js";
+import { profileOf, shareAtOrAbove, userProfile } from "../../data/profiles.js";
+import { NOTICE, SENTENCE, finding } from "../finding.js";
+
+export const name = "outsideProfile";
+export const mechanism = "threshold";
+/** 대조하는 문장 지표와 지적문의 이름과 단위. 파이썬 outsideProfile.py 와 같다. */
+const FEATURES = [
+  ["length", "문장 길이", "어절"],
+  ["commas", "쉼표", "개"],
+  ["newTopics", "처음 나온 화제어", "개"],
+  ["hedges", "헤지 표현", "개"],
+];
+
+/** @param {import("../../config/settings.js").Config} config */
+function profileFor(config) {
+  if (config.profile) return userProfile(config.profile);
+  const kind = PROFILE_OF[config.preset];
+  return kind ? profileOf(kind) : null;
+}
+
+/** @param {number} permille */
+function shareText(permille) {
+  return permille === 0 ? "0.1% 아래" : `${Math.floor(permille / 10)}.${permille % 10}%`;
+}
+
+/** @param {Set<string>} topics @param {Set<string>} known */
+function freshCount(topics, known) {
+  let fresh = 0;
+  for (const topic of topics) if (!known.has(topic)) fresh += 1;
+  return fresh;
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  const profile = profileFor(config);
+  if (!profile) return [];
+  const p = config.profilePercentile;
+  const findings = [];
+  for (const sentence of doc.sentences) {
+    const known = doc.reader.beforeSentence[sentence.index].known;
+    const values = { length: sentence.length, commas: sentence.commas, newTopics: freshCount(sentence.topics, known), hedges: sentence.hedges };
+    for (const [key, label, unit] of FEATURES) {
+      const hist = profile.sentence.get(key);
+      if (!hist || !hist.percentiles.has(p)) continue;
+      const limit = /** @type {number} */ (hist.percentiles.get(p));
+      const value = values[/** @type {"length" | "commas" | "newTopics" | "hedges"} */ (key)];
+      if (limit === 0 || value <= limit) continue;
+      findings.push(
+        finding(
+          name,
+          sentence.line,
+          sentence.text,
+          `${label} ${value}${unit}. ${profile.label} ${profile.sentences}문장 가운데 상위 ${shareText(shareAtOrAbove(hist, value))}다. ${p}%는 ${limit}${unit} 이하다`,
+          null,
+          NOTICE,
+          SENTENCE,
+          sentence.index,
+        ),
+      );
+    }
+  }
+  return findings;
+}