hanlint 0.0.16 → 0.0.18

package/src/report/textReport.js

@@ -35,21 +35,40 @@ function candidateLines(findings) {
   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}  집은 자리 없음`;
+/** 접은 확인 권고. 규칙마다 개수와 줄 번호 한 줄. 뜻은 파이썬 textReport.py 의 noticeLines 가 소유한다. @param {import("../rules/finding.js").Finding[]} notices */
+function noticeLines(notices) {
+  /** @type {Map<string, number[]>} */
+  const byRule = new Map();
+  for (const finding of notices) {
+    if (!byRule.has(finding.rule)) byRule.set(finding.rule, []);
+    /** @type {number[]} */ (byRule.get(finding.rule)).push(finding.line);
+  }
+  const lines = [`확인 권고 ${notices.length}건 (접음. 다 보려면 --notices)`];
+  for (const rule of [...byRule.keys()].sort()) {
+    const numbers = [...new Set(/** @type {number[]} */ (byRule.get(rule)))].sort((a, b) => a - b);
+    lines.push(`  ${rule} ${/** @type {number[]} */ (byRule.get(rule)).length}  ${numbers.join(", ")}줄`);
+  }
+  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] @param {boolean} [unfoldNotices] */
+export function renderText(path, findings, register = null, preset = null, customExemplars = [], unfoldNotices = false) {
+  if (!findings.length) return `${path}  오류 없음`;
   const errors = findings.filter((f) => f.severity === "error").length;
   const notices = findings.length - errors;
-  const summary = `${path}  집은 자리 ${errors}` + (notices ? `, 확인할 자리 ${notices}` : "");
+  const summary = `${path}  오류 ${errors}건` + (notices ? `, 확인 권고 ${notices}건` : "");
   const lines = [summary, ""];
-  for (const f of findings) {
+  const folded = unfoldNotices ? [] : findings.filter((f) => f.severity === "notice");
+  const shown = findings.filter((f) => unfoldNotices || f.severity === "error");
+  for (const f of shown) {
     const tag = `[${f.rule}]` + (f.severity === "notice" ? " 확인" : "");
     lines.push(`${path}:${f.line}  ${tag}`, `  ${f.quote}`, `  ${f.why}`);
-    if (f.fix) lines.push(`  고친 뒤: ${f.fix}`);
+    if (f.fix) lines.push(`  ${f.severity === "notice" ? "검토할 대안" : "고친 뒤"}: ${f.fix}`);
     lines.push("");
   }
-  lines.push(...exemplarLines(findings, register, preset, customExemplars));
-  const candidates = candidateLines(findings);
+  if (folded.length) lines.push(...noticeLines(folded), "");
+  lines.push(...exemplarLines(shown, register, preset, customExemplars));
+  const candidates = candidateLines(shown);
   if (candidates.length) lines.push("", ...candidates);
   return lines.join("\n").replace(/\n+$/, "");
 }

package/src/report/writingSpec.js

@@ -34,7 +34,7 @@ function selectedProfile(config) {
 }
 
 /**
- * 현재 규칙판을 쓰기 전 숫자 사양으로 편다. 품질 점수나 새 임계는 만들지 않는다.
+ * 현재 규칙 세트를 쓰기 전 숫자 사양으로 편다. 품질 점수나 새 임계는 만들지 않는다.
  * @param {import("./settings.js").Config} [config]
  * @param {string} [register]
  * @param {number | null} [targetChars]
@@ -161,11 +161,11 @@ export function writingSpec(config = defaultConfig(), register = HAPNIDA, target
   };
 }
 
-/** 사람이 읽는 꼴. basis는 JSON에서 확인한다. @param {ReturnType<typeof writingSpec>} spec */
+/** 사람이 읽는 형식. basis는 JSON에서 확인한다. @param {ReturnType<typeof writingSpec>} spec */
 export function renderWritingSpec(spec) {
   const target = spec.targetChars !== null ? `, ${spec.targetChars}자` : "";
   const lines = [
-    `hanlint spec  ${spec.preset} 종류, ${spec.register}체${target}. 같은 규칙판의 임계와 ${spec.profile} 프로파일을 쓰기 전 숫자로 편다`,
+    `hanlint spec  ${spec.preset} 종류, ${spec.register}체${target}. 같은 규칙 세트의 임계와 ${spec.profile} 프로파일을 쓰기 전 숫자로 편다`,
   ];
   const width = Math.max(...spec.rows.map((row) => row.label.length));
   for (const row of spec.rows) lines.push(`  ${row.label.padEnd(width)}  ${row.guidance}`);

package/src/rules/registry.js

@@ -24,9 +24,11 @@ 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 calqueFrame from "./sentence/calqueFrame.js";
 import * as cliche from "./sentence/cliche.js";
 import * as hardWord from "./sentence/hardWord.js";
 import * as connectorRepeat from "./sentence/connectorRepeat.js";
+import * as phraseRepeat from "./sentence/phraseRepeat.js";
 import * as danglingDeixis from "./sentence/danglingDeixis.js";
 import * as draftHistory from "./sentence/draftHistory.js";
 import * as numberOrphan from "./sentence/numberOrphan.js";
@@ -70,8 +72,10 @@ import * as screenWord from "./screen/screenWord.js";
 
 /** @type {Rule[]} */
 export const RULES = [
+  calqueFrame,
   cliche,
   connectorRepeat,
+  phraseRepeat,
   danglingDeixis,
   dash,
   draftHistory,
@@ -133,7 +137,7 @@ export const RULES = [
 export const MECHANISMS = {
   dictionary: "사전. 낱말 목록과 정규식이 맞는 자리",
   repeat: "반복. 같은 모양이 창 안에서 N 번",
-  threshold: "셈. 지문의 값이 임계를 넘거나 모양이 계약과 다른 자리",
+  threshold: "셈. 분석표의 값이 임계를 넘거나 모양이 계약과 다른 자리",
   contrast: "대조. 두 자리를 맞대 어긋난 곳",
   reader: "독자 상태. 문장 순서대로 독자가 손에 든 것과 본 것에 그 자리가 요구하는 것을 맞댄다",
 };

package/src/rules/screen/screenWord.js

@@ -1,10 +1,11 @@
 // @ts-check
 import { overridingFindings } from "../shared/dictionaryRule.js";
+import { NOTICE } from "../finding.js";
 
 export const name = "screenWord";
 export const mechanism = "dictionary";
 
 /** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
 export function run(doc) {
-  return overridingFindings(doc, "screenWord", name);
+  return overridingFindings(doc, "screenWord", name, undefined, NOTICE);
 }

package/src/rules/sentence/calqueFrame.js

@@ -0,0 +1,11 @@
+// @ts-check
+import { overridingFindings } from "../shared/dictionaryRule.js";
+import { NOTICE } from "../finding.js";
+
+export const name = "calqueFrame";
+export const mechanism = "dictionary";
+
+/** @param {import("../../fingerprint/build.js").DocumentPrint} doc */
+export function run(doc) {
+  return overridingFindings(doc, "calqueFrame", name, undefined, NOTICE);
+}

package/src/rules/sentence/cliche.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 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) {
-  return dictionaryFindings(doc, "cliches", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "cliches", name, ERROR, config);
 }

package/src/rules/sentence/hardWord.js

@@ -5,7 +5,10 @@ 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) {
-  return dictionaryFindings(doc, "easyWords", name, NOTICE);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "easyWords", name, NOTICE, config);
 }

package/src/rules/sentence/japaneseLoan.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 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) {
-  return dictionaryFindings(doc, "japaneseLoan", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "japaneseLoan", name, ERROR, config);
 }

package/src/rules/sentence/nounPile.js

@@ -1,4 +1,6 @@
 // @ts-check
+import { nounRuns } from "../../analysis/index.js";
+import { attested, usageKindOf } from "../../usage/counts.js";
 import { SENTENCE, finding } from "../finding.js";
 
 export const name = "nounPile";
@@ -10,12 +12,16 @@ export const mechanism = "threshold";
  */
 export function run(doc, config) {
   const findings = [];
+  const kind = usageKindOf(config);
   for (const sentence of doc.sentences) {
-    if (sentence.nounRun >= config.nounPileMin) {
-      findings.push(
-        finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
-      );
+    if (sentence.nounRun < config.nounPileMin) continue;
+    if (kind) {
+      const piles = nounRuns(sentence.text).filter(([, length]) => length >= config.nounPileMin).map(([chain]) => chain);
+      if (piles.length && piles.every((chain) => attested(chain, kind, config.usageMin))) continue;
     }
+    findings.push(
+      finding(name, sentence.line, sentence.text, `명사 ${sentence.nounRun}개가 조사 없이 이어진다. 관계가 표시되지 않아 독자가 조사를 끼워 넣는다. 동사로 되돌린다`, null, config.enforceStyle.includes(name) ? "error" : "notice", SENTENCE, sentence.index),
+    );
   }
   return findings;
 }

package/src/rules/sentence/phraseRepeat.js

@@ -0,0 +1,53 @@
+// @ts-check
+import { loadEntries } from "../../data/load.js";
+import { compile } from "../../regex.js";
+import { DOCUMENT, NOTICE, finding } from "../finding.js";
+
+export const name = "phraseRepeat";
+export const mechanism = "repeat";
+
+/** 산문 문장이 이 수보다 적으면 비율이 튄다. 뜻은 파이썬 rules/sentence/phraseRepeat.py 가 소유한다. */
+const MIN_SENTENCES = 8;
+/** 되풀이로 세려면 몇 번 나와야 하는가. 한 번은 버릇이 아니다. */
+const MIN_HITS = 2;
+
+/** @returns {{pattern: import("../../regex.js").Pattern, share: number, label: string, why: string, source: string}[]} */
+function entries() {
+  return loadEntries("phraseRepeat.json").map((one) => ({
+    pattern: compile(String(one.pattern)),
+    share: Number(one.share),
+    label: String(one.label),
+    why: String(one.why),
+    source: String(one.source),
+  }));
+}
+
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  void config;
+  const findings = [];
+  const prose = doc.sentences.filter((one) => one.length > 0 && one.ending !== "없음");
+  if (prose.length < MIN_SENTENCES) return findings;
+  for (const { pattern, share, label, why, source } of entries()) {
+    const hit = prose.filter((one) => pattern.search(one.text) !== null);
+    if (hit.length < MIN_HITS || hit.length / prose.length <= share) continue;
+    const lines = [...new Set(hit.map((one) => one.line))].sort((a, b) => a - b).join(", ");
+    const share100 = `${Math.round(share * 100)}%`;
+    findings.push(
+      finding(
+        name,
+        hit[0].line,
+        hit[0].text,
+        `\`${label}\` 꼴이 산문 ${prose.length}문장 가운데 ${hit.length}번이다 (${lines}줄. 상한 ${share100}). ${why} (${source})`,
+        null,
+        NOTICE,
+        DOCUMENT,
+        -1,
+      ),
+    );
+  }
+  return findings;
+}

package/src/rules/sentence/redundantPair.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 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) {
-  return dictionaryFindings(doc, "redundantPair", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "redundantPair", name, ERROR, config);
 }

package/src/rules/sentence/translationese.js

@@ -1,10 +1,14 @@
 // @ts-check
+import { ERROR } from "../finding.js";
 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) {
-  return dictionaryFindings(doc, "translationese", name);
+/**
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {import("../../config/settings.js").Config} config
+ */
+export function run(doc, config) {
+  return dictionaryFindings(doc, "translationese", name, ERROR, config);
 }

package/src/rules/shared/dictionaryRule.js

@@ -1,6 +1,7 @@
 // @ts-check
 /** 사전 규칙의 공통 구현. cliche, translationese, redundantPair, japaneseLoan 이 사전 이름만 바꿔 쓴다. */
 import { fitJosa } from "../../analysis/grammar/josa.js";
+import { conventional, usageKindOf } from "../../usage/counts.js";
 import { ERROR, SENTENCE, finding } from "../finding.js";
 
 /**
@@ -41,11 +42,24 @@ function matchFinding(sentence, match, ruleName, severity) {
   );
 }
 
-export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR) {
+/**
+ * 사전의 매치를 지적으로. config 를 주면 그 종류의 관용 항목 (usage.conventional) 은 넘긴다. 뜻은 파이썬
+ * rules/shared/dictionaryRule.py 의 dictionaryFindings 가 소유한다.
+ * @param {import("../../fingerprint/build.js").DocumentPrint} doc
+ * @param {string} dictionary
+ * @param {string} ruleName
+ * @param {string} [severity]
+ * @param {import("../../config/settings.js").Config | null} [config]
+ * @returns {import("../finding.js").Finding[]}
+ */
+export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR, config = null) {
   const findings = [];
+  const kind = config ? usageKindOf(config) : null;
   for (const sentence of doc.sentences) {
     for (const match of sentence.matches) {
-      if (match.dictionary === dictionary) findings.push(matchFinding(sentence, match, ruleName, severity));
+      if (match.dictionary !== dictionary) continue;
+      if (kind && config && conventional(dictionary, match.pattern, kind, config.usageShare)) continue;
+      findings.push(matchFinding(sentence, match, ruleName, severity));
     }
   }
   return findings;
@@ -57,9 +71,10 @@ export function dictionaryFindings(doc, dictionary, ruleName, severity = ERROR)
  * @param {string} dictionary
  * @param {string} ruleName
  * @param {string} [severity]
+ * @param {string | null} [builtinSeverity]
  * @returns {import("../finding.js").Finding[]}
  */
-export function overridingFindings(doc, dictionary, ruleName, severity = ERROR) {
+export function overridingFindings(doc, dictionary, ruleName, severity = ERROR, builtinSeverity = null) {
   const findings = [];
   for (const sentence of doc.sentences) {
     /** @type {Map<string, import("../../fingerprint/dictionaries.js").DictionaryMatch>} */
@@ -67,14 +82,15 @@ export function overridingFindings(doc, dictionary, ruleName, severity = ERROR)
     for (const match of sentence.matches) {
       if (match.dictionary === dictionary) chosen.set(`${match.start}:${match.end}`, match);
     }
-    for (const match of [...chosen.values()].sort((a, b) => a.start - b.start)) findings.push(matchFinding(sentence, match, ruleName, severity));
+    for (const match of [...chosen.values()].sort((a, b) => a.start - b.start)) findings.push(matchFinding(sentence, match, ruleName, match.pattern && builtinSeverity ? builtinSeverity : severity));
   }
   return findings;
 }
 
 /**
  * 문장마다 가장 앞의 매치 하나만 지적한다. 뜻은 파이썬 rules/shared/dictionaryRule.py 의 firstMatchFindings 가 소유한다.
- * 구체 무늬와 종결어미가 한 사전에 같이 사는 화면 사전에 쓴다. fix 는 내지 않는다.
+ * 구체 무늬와 종결어미가 한 사전에 같이 사는 화면 사전에 쓴다. 항목에 to 규칙이 있으면 문장 전체를 낱말로 다시 쓴
+ * 제안을 fix 로 낸다 (진행, 실패, 요구, 완료). 뜻을 골라야 하는 일반 종결어미는 to 가 없어 fix 도 없다.
  * @param {import("../../fingerprint/build.js").DocumentPrint} doc
  * @param {string} dictionary
  * @param {string} ruleName
@@ -86,18 +102,33 @@ export function firstMatchFindings(doc, dictionary, ruleName, severity = ERROR)
   for (const sentence of doc.sentences) {
     const match = sentence.matches.find((m) => m.dictionary === dictionary);
     if (!match) continue;
+    const [fragment, replacement] = match.rewrite ? changedSpan(sentence.text, match.rewrite) : [null, null];
     findings.push(
       finding(
         ruleName,
         sentence.line + countNewlines(sentence.text.slice(0, match.start)),
         sentence.text,
         `\`${match.text}\` ${match.why} (${match.source})`,
-        null,
+        match.rewrite,
         severity,
         SENTENCE,
         sentence.index,
+        fragment,
+        replacement,
       ),
     );
   }
   return findings;
 }
+
+/**
+ * 두 글의 공통 앞뒤를 뺀 바뀐 조각. 편집기의 `이대로 고치기` 가 이 조각만 바꾼다. 뜻은 파이썬 changedSpan 이 소유한다.
+ * @param {string} before @param {string} after @returns {[string, string]}
+ */
+export function changedSpan(before, after) {
+  let head = 0;
+  while (head < Math.min(before.length, after.length) && before[head] === after[head]) head++;
+  let tail = 0;
+  while (tail < Math.min(before.length, after.length) - head && before[before.length - 1 - tail] === after[after.length - 1 - tail]) tail++;
+  return [before.slice(head, before.length - tail), after.slice(head, after.length - tail)];
+}

package/src/text.js

@@ -64,7 +64,7 @@ export function countIn(text, needle, end = text.length) {
 
 /**
  * 파이썬 round(value, digits). 정확한 이진 값을 십진으로 풀어 반올림하고 정확히 절반이면 짝수로 간다.
- * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 판의 글자가 같으려면 파이썬 쪽이다.
+ * Math.round 는 절반을 위로 올려 13/16 을 0.813 으로 만들고 파이썬은 0.812 다. 두 구현의 글자가 같으려면 파이썬 쪽이다.
  * toFixed(100) 은 1e21 아래의 수를 정확한 십진 전개로 준다. 지문의 비율과 평균이 사는 범위다.
  * @param {number} value
  * @param {number} digits

package/src/usage/counts.js

@@ -0,0 +1,54 @@
+// @ts-check
+/**
+ * 명사 연쇄 빈도표. 글 종류마다 data/usageCounts.<종류>.json 하나이고 값은 그 연쇄가 나온 문서 수다.
+ * 뜻은 파이썬 usage/counts.py 가 소유한다. 표의 키는 nounRuns 의 어절들을 빈칸 하나로 이은 것이다.
+ */
+import { USAGE_OF } from "../config/settings.js";
+import { readText } from "../data/load.js";
+
+/** @typedef {{ kind: string, source: string, documents: number, minLength: number, minDocuments: number, chains: Record<string, number>, patterns?: Record<string, Record<string, number>> }} UsageTable */
+
+/** @type {Map<string, UsageTable>} */
+const tables = new Map();
+
+/**
+ * 이 설정이 볼 빈도표의 종류. usageKind 가 null 이면 프리셋이 정하고 "" 면 보지 않는다.
+ * @param {import("../config/settings.js").Config} config @returns {string | null}
+ */
+export function usageKindOf(config) {
+  const kind = config.usageKind === null ? USAGE_OF[config.preset] : config.usageKind;
+  return kind || null;
+}
+
+/** 표 전체. @param {string} kind @returns {UsageTable} */
+export function usageTable(kind) {
+  let table = tables.get(kind);
+  if (!table) {
+    table = JSON.parse(readText(`usageCounts.${kind}.json`));
+    tables.set(kind, /** @type {UsageTable} */ (table));
+  }
+  return /** @type {UsageTable} */ (table);
+}
+
+/** 이 연쇄가 그 종류의 말뭉치에서 몇 편의 문서에 나왔나. 표에 없으면 0. @param {string[]} chain @param {string} kind */
+export function chainDocuments(chain, kind) {
+  return usageTable(kind).chains[chain.join(" ")] ?? 0;
+}
+
+/** 연쇄가 minimum 편 이상의 문서에 나왔으면 그 종류의 관용이다. @param {string[]} chain @param {string} kind @param {number} minimum */
+export function attested(chain, kind, minimum) {
+  return chainDocuments(chain, kind) >= minimum;
+}
+
+/** 사전 항목이 그 종류의 말뭉치에서 몇 편의 문서에 나왔나. @param {string} dictionary @param {string} pattern @param {string} kind */
+export function patternDocuments(dictionary, pattern, kind) {
+  return usageTable(kind).patterns?.[dictionary]?.[pattern] ?? 0;
+}
+
+/**
+ * 사전 항목이 그 종류의 문서 share 이상에 나오면 관용이다. 뜻은 파이썬 usage/counts.py 의 conventional 이 소유한다.
+ * @param {string} dictionary @param {string} pattern @param {string} kind @param {number} share
+ */
+export function conventional(dictionary, pattern, kind, share) {
+  return patternDocuments(dictionary, pattern, kind) >= share * usageTable(kind).documents;
+}

package/src/usage/index.js

@@ -0,0 +1,8 @@
+// @ts-check
+/**
+ * 용례 (usage). 실제 글에서 낱말이 어떻게 쓰였는지를 든다. 뜻은 파이썬 usage/ 가 소유한다.
+ * counts 는 실리는 빈도표, sentences 는 사용자 기계의 문장 역인덱스다.
+ * fingerprint 와 같은 층이다. rules 와 cli 가 쓰고, analysis 와 config 와 data 만 쓴다.
+ */
+export { attested, chainDocuments, conventional, patternDocuments, usageKindOf, usageTable } from "./counts.js";
+export { UsageIndex, buildIndex, defaultRoot as defaultUsageRoot, indexTokens, listIndexes, loadIndex, queryCores, readDocuments } from "./sentences.js";