hanlint 0.0.1

package/src/config/settings.js

@@ -0,0 +1,80 @@
+// @ts-check
+/**
+ * 설정과 임계 기본값. 정본은 파이썬 config/settings.py 이고 여기는 같은 값을 든다. 필드 이름이 곧 설정 파일의 키다.
+ * 기본값을 바꾸면 양쪽을 같은 작업에서 바꾼다. tests/parity 가 두 구현의 결과를 견준다.
+ */
+
+export const ANALYZERS = ["surface", "kiwi"];
+
+/**
+ * @typedef {object} Config
+ * @property {Set<string>} disable 끌 규칙 이름
+ * @property {string} analyzer
+ * @property {string | null} keywordField
+ * @property {string | null} profile
+ * @property {Record<string, unknown[]>} dictionary
+ * @property {string | null} source 설정을 읽은 파일. 기본값이면 null. loadConfig 가 채운다
+ * @property {number} fragmentRun
+ * @property {number} introMaxParagraphs
+ * @property {number} headingUniformRatio
+ * @property {number} nounPileMin
+ * @property {number} endingRun
+ * @property {number} factListMinSentences
+ * @property {number} factListMaxMeanLength
+ * @property {number} topicBreakMinSentences
+ * @property {number} longSentenceMax
+ * @property {number} duplicateBlockRatio
+ * @property {number} firstResultMaxParagraphs
+ * @property {number} sectionResultMinParagraphs
+ */
+
+/** @returns {Config} */
+export function defaultConfig() {
+  return {
+    disable: new Set(),
+    analyzer: "surface",
+    keywordField: null,
+    profile: null,
+    dictionary: {},
+    source: null,
+    fragmentRun: 3,
+    introMaxParagraphs: 4,
+    headingUniformRatio: 0.75,
+    nounPileMin: 5,
+    endingRun: 4,
+    factListMinSentences: 3,
+    factListMaxMeanLength: 8.0,
+    topicBreakMinSentences: 2,
+    longSentenceMax: 30,
+    duplicateBlockRatio: 0.9,
+    firstResultMaxParagraphs: 4,
+    sectionResultMinParagraphs: 3,
+  };
+}
+
+/** @param {Config} config @param {string} ruleName */
+export function enabled(config, ruleName) {
+  return !config.disable.has(ruleName);
+}
+
+/** @param {Record<string, unknown>} data @returns {Config} */
+export function configFromMapping(data) {
+  const config = defaultConfig();
+  for (const [key, value] of Object.entries(data)) {
+    if (key === "disable") {
+      config.disable = new Set(/** @type {string[]} */ (value));
+    } else if (key === "analyzer") {
+      if (!ANALYZERS.includes(/** @type {string} */ (value))) {
+        throw new Error(`analyzer 는 ${ANALYZERS.join(" 또는 ")} 다: ${value}`);
+      }
+      config.analyzer = /** @type {string} */ (value);
+    } else if (key === "dictionary") {
+      config.dictionary = { .../** @type {Record<string, unknown[]>} */ (value) };
+    } else if (key !== "source" && key in config) {
+      config[key] = value;
+    } else {
+      throw new Error(`모르는 설정 키: ${key}. hanlint init 이 만드는 파일의 키만 쓴다`);
+    }
+  }
+  return config;
+}

package/src/config/toml.js

@@ -0,0 +1,239 @@
+// @ts-check
+/**
+ * hanlint 설정에 쓰이는 TOML 부분집합을 읽는다. 의존성 0 을 지키려고 직접 쓴다.
+ *
+ * 되는 것: 주석, `key = 값`, 점 키, `[table]`, `[[array]]`, 문자열 ("..." 와 '...'), 정수, 실수, 불리언,
+ * 여러 줄 배열, 인라인 테이블. 안 되는 것: 여러 줄 문자열, 날짜. 만나면 어디서 막혔는지 말하고 던진다.
+ */
+
+const BACKSLASH = String.fromCharCode(92);
+/** @type {Record<string, string>} */
+const SIMPLE_ESCAPES = { n: "\n", t: "\t", r: "\r", '"': '"', b: "\b", f: "\f", [BACKSLASH]: BACKSLASH };
+
+/** @param {string} text @returns {Record<string, unknown>} */
+export function parseToml(text) {
+  return new Parser(text).document();
+}
+
+class Parser {
+  /** @param {string} text */
+  constructor(text) {
+    this.text = text;
+    this.pos = 0;
+    /** @type {Record<string, unknown>} */
+    this.root = {};
+    this.current = this.root;
+  }
+
+  /** @param {string} message */
+  error(message) {
+    const line = this.text.slice(0, this.pos).split("\n").length;
+    return new Error(`TOML ${line}번째 줄: ${message}. hanlint 가 읽는 TOML 부분집합이 아니다`);
+  }
+
+  document() {
+    for (;;) {
+      this.skipBlank();
+      if (this.pos >= this.text.length) return this.root;
+      if (this.text.startsWith("[[", this.pos)) this.arrayTable();
+      else if (this.text[this.pos] === "[") this.table();
+      else this.keyValue(this.current);
+      this.endOfLine();
+    }
+  }
+
+  skipBlank() {
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos];
+      if (c === "#") {
+        while (this.pos < this.text.length && this.text[this.pos] !== "\n") this.pos++;
+      } else if (c === " " || c === "\t" || c === "\n" || c === "\r") {
+        this.pos++;
+      } else {
+        return;
+      }
+    }
+  }
+
+  skipSpaces() {
+    while (this.pos < this.text.length && (this.text[this.pos] === " " || this.text[this.pos] === "\t")) this.pos++;
+  }
+
+  endOfLine() {
+    this.skipSpaces();
+    if (this.pos >= this.text.length) return;
+    const c = this.text[this.pos];
+    if (c === "#") {
+      while (this.pos < this.text.length && this.text[this.pos] !== "\n") this.pos++;
+      return;
+    }
+    if (c === "\n" || c === "\r") return;
+    throw this.error(`줄 끝에 남은 글자 '${c}'`);
+  }
+
+  /** @returns {string[]} */
+  keyPath() {
+    const parts = [];
+    for (;;) {
+      this.skipSpaces();
+      const c = this.text[this.pos];
+      if (c === '"' || c === "'") {
+        parts.push(this.string());
+      } else {
+        const match = /^[A-Za-z0-9_-]+/.exec(this.text.slice(this.pos));
+        if (!match) throw this.error("키가 없다");
+        parts.push(match[0]);
+        this.pos += match[0].length;
+      }
+      this.skipSpaces();
+      if (this.text[this.pos] === ".") {
+        this.pos++;
+        continue;
+      }
+      return parts;
+    }
+  }
+
+  /** @param {Record<string, unknown>} base @param {string[]} parts */
+  descend(base, parts) {
+    let node = base;
+    for (const part of parts) {
+      if (!(part in node)) node[part] = {};
+      const next = node[part];
+      if (Array.isArray(next)) node = /** @type {Record<string, unknown>} */ (next[next.length - 1]);
+      else if (typeof next === "object" && next !== null) node = /** @type {Record<string, unknown>} */ (next);
+      else throw this.error(`${part} 는 테이블이 아니다`);
+    }
+    return node;
+  }
+
+  table() {
+    this.pos++;
+    const parts = this.keyPath();
+    if (this.text[this.pos] !== "]") throw this.error("] 가 없다");
+    this.pos++;
+    this.current = this.descend(this.root, parts);
+  }
+
+  arrayTable() {
+    this.pos += 2;
+    const parts = this.keyPath();
+    if (!this.text.startsWith("]]", this.pos)) throw this.error("]] 가 없다");
+    this.pos += 2;
+    const parent = this.descend(this.root, parts.slice(0, -1));
+    const name = parts[parts.length - 1];
+    if (!(name in parent)) parent[name] = [];
+    const list = parent[name];
+    if (!Array.isArray(list)) throw this.error(`${name} 은 배열이 아니다`);
+    /** @type {Record<string, unknown>} */
+    const entry = {};
+    list.push(entry);
+    this.current = entry;
+  }
+
+  /** @param {Record<string, unknown>} target */
+  keyValue(target) {
+    const parts = this.keyPath();
+    if (this.text[this.pos] !== "=") throw this.error("= 가 없다");
+    this.pos++;
+    this.skipSpaces();
+    const node = this.descend(target, parts.slice(0, -1));
+    node[parts[parts.length - 1]] = this.value();
+  }
+
+  /** @returns {unknown} */
+  value() {
+    this.skipSpaces();
+    const c = this.text[this.pos];
+    if (c === '"' || c === "'") return this.string();
+    if (c === "[") return this.array();
+    if (c === "{") return this.inlineTable();
+    const rest = this.text.slice(this.pos);
+    const bool = /^(true|false)(?![A-Za-z0-9_])/.exec(rest);
+    if (bool) {
+      this.pos += bool[0].length;
+      return bool[1] === "true";
+    }
+    const number = /^[+-]?(?:\d[\d_]*)(?:\.\d[\d_]*)?(?:[eE][+-]?\d+)?(?![A-Za-z_])/.exec(rest);
+    if (number) {
+      this.pos += number[0].length;
+      return Number(number[0].replace(/_/g, ""));
+    }
+    throw this.error(`값을 읽을 수 없다: '${rest.slice(0, 12)}'`);
+  }
+
+  string() {
+    const quote = this.text[this.pos];
+    if (this.text.startsWith(quote.repeat(3), this.pos)) throw this.error("여러 줄 문자열은 지원하지 않는다");
+    this.pos++;
+    let out = "";
+    while (this.pos < this.text.length) {
+      const c = this.text[this.pos];
+      if (c === quote) {
+        this.pos++;
+        return out;
+      }
+      if (c === "\n") throw this.error("문자열이 닫히지 않았다");
+      if (quote === '"' && c === BACKSLASH) {
+        const next = this.text[this.pos + 1];
+        if (next in SIMPLE_ESCAPES) {
+          out += SIMPLE_ESCAPES[next];
+          this.pos += 2;
+          continue;
+        }
+        if (next === "u" || next === "U") {
+          const width = next === "u" ? 4 : 8;
+          const hex = this.text.slice(this.pos + 2, this.pos + 2 + width);
+          out += String.fromCodePoint(parseInt(hex, 16));
+          this.pos += 2 + width;
+          continue;
+        }
+        throw this.error(`모르는 이스케이프 ${BACKSLASH}${next}`);
+      }
+      out += c;
+      this.pos++;
+    }
+    throw this.error("문자열이 닫히지 않았다");
+  }
+
+  array() {
+    this.pos++;
+    /** @type {unknown[]} */
+    const items = [];
+    for (;;) {
+      this.skipBlank();
+      if (this.text[this.pos] === "]") {
+        this.pos++;
+        return items;
+      }
+      items.push(this.value());
+      this.skipBlank();
+      if (this.text[this.pos] === ",") this.pos++;
+      else if (this.text[this.pos] !== "]") throw this.error("배열에 , 나 ] 가 없다");
+    }
+  }
+
+  inlineTable() {
+    this.pos++;
+    /** @type {Record<string, unknown>} */
+    const table = {};
+    this.skipSpaces();
+    if (this.text[this.pos] === "}") {
+      this.pos++;
+      return table;
+    }
+    for (;;) {
+      this.keyValue(table);
+      this.skipSpaces();
+      if (this.text[this.pos] === ",") {
+        this.pos++;
+        continue;
+      }
+      if (this.text[this.pos] === "}") {
+        this.pos++;
+        return table;
+      }
+      throw this.error("인라인 테이블에 , 나 } 가 없다");
+    }
+  }
+}

package/src/data/load.js

@@ -0,0 +1,63 @@
+// @ts-check
+/**
+ * data 폴더를 읽는다. 파이썬 정본의 투영이라 파일 모양이 같다. txt 는 한 줄에 항목 하나, json 은 toml 을 옮긴 것.
+ * 한 번 읽은 것은 기억한다.
+ */
+import { readFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { compile } from "../regex.js";
+
+const DATA_DIR = join(dirname(fileURLToPath(import.meta.url)), "..", "..", "data");
+/** @type {Map<string, unknown>} */
+const cache = new Map();
+
+/**
+ * @template T
+ * @param {string} key
+ * @param {() => T} make
+ * @returns {T}
+ */
+function cached(key, make) {
+  if (!cache.has(key)) cache.set(key, make());
+  return /** @type {T} */ (cache.get(key));
+}
+
+/** @param {string} name */
+export function readText(name) {
+  return readFileSync(join(DATA_DIR, name), "utf-8");
+}
+
+/** `#` 으로 시작하면 주석, 빈 줄은 무시. @param {string} name @returns {string[]} */
+export function loadLines(name) {
+  return cached(`lines:${name}`, () =>
+    readText(name)
+      .split(/\r?\n/)
+      .map((line) => line.trim())
+      .filter((line) => line && !line.startsWith("#")),
+  );
+}
+
+/** 한 줄에 정규식 하나. @param {string} name */
+export function loadPatterns(name) {
+  return cached(`patterns:${name}`, () => loadLines(name).map((line) => compile(line)));
+}
+
+/** toml 의 `[[entry]]` 목록. @param {string} name @returns {Record<string, unknown>[]} */
+export function loadEntries(name) {
+  return cached(`entries:${name}`, () => {
+    const data = JSON.parse(readText(name.replace(/\.toml$/, ".json")));
+    return data.entry ?? [];
+  });
+}
+
+/** @returns {Record<string, string>} 규칙 이름 → 기술서 (파이썬 docstring 의 투영) */
+export function loadRuleDocs() {
+  return cached("ruleDocs", () => JSON.parse(readText("ruleDocs.json")));
+}
+
+/** @returns {string} */
+export function loadVersion() {
+  return cached("version", () => JSON.parse(readText("version.json")).version);
+}

package/src/document/model.js

@@ -0,0 +1,55 @@
+// @ts-check
+/**
+ * 문서 모델. 세 층이다. Block (빈 줄로 나뉜 덩어리), Section (H2 하나가 여는 절), Document (전체).
+ * 줄 번호는 1 부터 세고 원문 기준이다.
+ */
+
+export const PROSE = "prose";
+export const HEADING = "heading";
+export const CODE = "code";
+export const IMAGE = "image";
+export const LIST = "list";
+export const TABLE = "table";
+export const EMBED = "embed";
+export const HTML = "html";
+
+/**
+ * @typedef {object} Block
+ * @property {string} kind
+ * @property {number} startLine
+ * @property {number} endLine
+ * @property {string} text
+ * @property {number} level heading 일 때 `#` 의 개수
+ * @property {number} index 문서 안 순서
+ */
+
+/**
+ * @typedef {object} Section
+ * @property {Block | null} heading
+ * @property {Block[]} blocks
+ */
+
+/**
+ * @typedef {object} Document
+ * @property {string | null} path
+ * @property {Record<string, string>} frontmatter
+ * @property {Block[]} blocks
+ * @property {Section[]} sections
+ * @property {[string, number, number][]} disabled 인라인 제어가 끈 (규칙 또는 *, 시작 줄, 끝 줄)
+ */
+
+/** @param {Section} section */
+export function sectionTitle(section) {
+  return section.heading ? section.heading.text : "";
+}
+
+/** @param {Section} section */
+export function sectionStartLine(section) {
+  if (section.heading) return section.heading.startLine;
+  return section.blocks.length ? section.blocks[0].startLine : 1;
+}
+
+/** @param {Document} doc @param {number | null} [level] */
+export function headingsOf(doc, level = null) {
+  return doc.blocks.filter((b) => b.kind === HEADING && (level === null || b.level === level));
+}

package/src/document/parseMarkdown.js

@@ -0,0 +1,183 @@
+// @ts-check
+/**
+ * 마크다운 텍스트를 문서 모델로 바꾼다. 파이썬 document/parseMarkdown.py 와 같은 판정이다.
+ * 빈 줄로 블록을 나누고 첫 줄로 종류를 정한다. 코드 펜스 안은 통째로 code 다. H2 가 절을 열고 첫 H2 앞은 도입 절이다.
+ */
+import { splitLines } from "../text.js";
+import { CODE, EMBED, HEADING, HTML, IMAGE, LIST, PROSE, TABLE } from "./model.js";
+
+const FRONTMATTER = /^---\r?\n([\s\S]*?)\r?\n---\r?\n/;
+const FENCE = /^\s*(```|~~~)/;
+const HEADING_LINE = /^(#{1,6})\s+(.*?)\s*#*\s*$/;
+const IMAGE_LINE = /^!\[/;
+const LIST_LINE = /^\s*(?:[-*+]|\d+[.)])\s+/;
+const TABLE_LINE = /^\s*\|/;
+const URL_LINE = /^\s*https?:\/\/\S+\s*$/;
+const HTML_LINE = /^\s*</;
+const META_KEY = /^[A-Za-z][A-Za-z0-9_]*$/;
+const CONTROL = /^\s*<!--\s*hanlint-(disable-next-line|disable-next|disable|enable)\b([^>]*?)-->\s*$/;
+const ALL_RULES = "*";
+
+/** frontmatter 를 읽고 본문이 시작하는 줄 번호 (1 부터) 를 함께 준다. @param {string} text */
+export function parseFrontmatter(text) {
+  const match = FRONTMATTER.exec(text);
+  if (!match) return { meta: {}, firstLine: 1 };
+  /** @type {Record<string, string>} */
+  const meta = {};
+  for (const line of splitLines(match[1])) {
+    const at = line.indexOf(":");
+    if (at < 0) continue;
+    const key = line.slice(0, at).trim();
+    if (META_KEY.test(key)) meta[key] = line.slice(at + 1).trim();
+  }
+  return { meta, firstLine: (match[0].match(/\n/g) ?? []).length + 1 };
+}
+
+/** @param {string} firstLine */
+export function classify(firstLine) {
+  if (HEADING_LINE.test(firstLine)) return HEADING;
+  if (IMAGE_LINE.test(firstLine)) return IMAGE;
+  if (TABLE_LINE.test(firstLine)) return TABLE;
+  if (LIST_LINE.test(firstLine)) return LIST;
+  if (URL_LINE.test(firstLine)) return EMBED;
+  if (HTML_LINE.test(firstLine)) return HTML;
+  return PROSE;
+}
+
+/**
+ * @param {string} text
+ * @param {number} firstLine
+ * @returns {import("./model.js").Block[]}
+ */
+export function splitBlocks(text, firstLine) {
+  /** @type {import("./model.js").Block[]} */
+  const blocks = [];
+  /** @type {string[]} */
+  let buffer = [];
+  let bufferStart = 0;
+  let lineNo = firstLine - 1;
+  /** @type {string | null} */
+  let fence = null;
+  let fenceStart = 0;
+  /** @type {string[]} */
+  let fenceLines = [];
+
+  const flush = () => {
+    if (!buffer.length) return;
+    const kind = classify(buffer[0]);
+    let joined = buffer.join("\n");
+    let level = 0;
+    if (kind === HEADING) {
+      const match = /** @type {RegExpExecArray} */ (HEADING_LINE.exec(buffer[0]));
+      level = match[1].length;
+      joined = match[2];
+    }
+    blocks.push({ kind, startLine: bufferStart, endLine: bufferStart + buffer.length - 1, text: joined, level, index: blocks.length });
+    buffer = [];
+  };
+
+  for (const raw of splitLines(text)) {
+    lineNo += 1;
+    const line = raw.replace(/\r+$/, "");
+    if (fence) {
+      fenceLines.push(line);
+      if (FENCE.test(line) && line.trim().startsWith(fence)) {
+        blocks.push({ kind: CODE, startLine: fenceStart, endLine: lineNo, text: fenceLines.join("\n"), level: 0, index: blocks.length });
+        fence = null;
+        fenceLines = [];
+      }
+      continue;
+    }
+    const opening = FENCE.exec(line);
+    if (opening) {
+      flush();
+      fence = opening[1];
+      fenceStart = lineNo;
+      fenceLines = [line];
+      continue;
+    }
+    if (!line.trim()) {
+      flush();
+      continue;
+    }
+    if (CONTROL.test(line)) {
+      flush();
+      blocks.push({ kind: HTML, startLine: lineNo, endLine: lineNo, text: line, level: 0, index: blocks.length });
+      continue;
+    }
+    if (HEADING_LINE.test(line) && buffer.length) flush();
+    if (!buffer.length) bufferStart = lineNo;
+    buffer.push(line);
+    if (HEADING_LINE.test(line)) flush();
+  }
+  flush();
+  if (fence) {
+    blocks.push({ kind: CODE, startLine: fenceStart, endLine: lineNo, text: fenceLines.join("\n"), level: 0, index: blocks.length });
+  }
+  return blocks;
+}
+
+/** @param {import("./model.js").Block[]} blocks @returns {import("./model.js").Section[]} */
+export function groupSections(blocks) {
+  /** @type {import("./model.js").Section[]} */
+  const sections = [{ heading: null, blocks: [] }];
+  for (const block of blocks) {
+    if (block.kind === HEADING && block.level === 2) {
+      sections.push({ heading: block, blocks: [] });
+      continue;
+    }
+    sections[sections.length - 1].blocks.push(block);
+  }
+  return sections;
+}
+
+/** @param {string} raw */
+function controlNames(raw) {
+  const names = raw.trim().split(/[\s,]+/).filter(Boolean);
+  return names.length ? names : [ALL_RULES];
+}
+
+/** @param {import("./model.js").Block[]} blocks @returns {[string, number, number][]} */
+export function disabledRanges(blocks) {
+  /** @type {[string, number, number][]} */
+  const ranges = [];
+  /** @type {Map<string, number>} */
+  const opened = new Map();
+  const lastLine = blocks.length ? blocks[blocks.length - 1].endLine : 1;
+  blocks.forEach((block, index) => {
+    const match = block.kind === HTML ? CONTROL.exec(block.text) : null;
+    if (!match) return;
+    const action = match[1];
+    const names = controlNames(match[2]);
+    if (action === "disable-next" || action === "disable-next-line") {
+      if (index + 1 < blocks.length) {
+        const target = blocks[index + 1];
+        for (const name of names) ranges.push([name, target.startLine, target.endLine]);
+      }
+    } else if (action === "disable") {
+      for (const name of names) if (!opened.has(name)) opened.set(name, block.startLine);
+    } else {
+      const closing = names.length === 1 && names[0] === ALL_RULES ? [...opened.keys()] : names;
+      for (const name of closing) {
+        if (opened.has(name)) {
+          ranges.push([name, /** @type {number} */ (opened.get(name)), block.endLine]);
+          opened.delete(name);
+        }
+      }
+    }
+  });
+  for (const [name, start] of opened) ranges.push([name, start, lastLine]);
+  return ranges;
+}
+
+/**
+ * @param {string} text
+ * @param {string | null} [path]
+ * @returns {import("./model.js").Document}
+ */
+export function parseMarkdown(text, path = null) {
+  const { meta, firstLine } = parseFrontmatter(text);
+  const body = firstLine === 1 ? text : splitLines(text).slice(firstLine - 1).join("\n");
+  const blocks = splitBlocks(body, firstLine);
+  return { path, frontmatter: meta, blocks, sections: groupSections(blocks), disabled: disabledRanges(blocks) };
+}

package/src/document/plainText.js

@@ -0,0 +1,43 @@
+// @ts-check
+/**
+ * 산문에서 마크다운 표식을 걷는다. 인라인 코드는 백틱만 떼고 내용은 남긴다. 링크는 보이는 글자만. 강조 표식은 뗀다.
+ * 줄바꿈은 남겨 줄 번호 계산에 쓴다. 파이썬 document/plainText.py 와 같다.
+ * 인라인 코드가 있던 자리는 codeSpans 로 다시 찾는다. 백틱 안은 사용이 아니라 인용이다.
+ */
+
+const INLINE_CODE = /`([^`\n]*)`/g;
+const LINK = /\[([^\]]*)\]\([^)]*\)/g;
+const EMPHASIS = /(\*\*|__)(?=\S)(.+?)(?<=\S)\1/g;
+// 파이썬의 \w 는 유니코드 글자라 한글을 포함한다. JS 는 \p{L}\p{N}_ 로 같은 뜻을 적는다.
+const SINGLE_EMPHASIS = /(?<![\p{L}\p{N}_*])\*(?=\S)([^*\n]+?)(?<=\S)\*(?![\p{L}\p{N}_*])/gu;
+const SPACES = /[ \t]+/g;
+
+/** @param {string} text */
+export function plainText(text) {
+  text = text.replace(INLINE_CODE, "$1");
+  text = text.replace(LINK, "$1");
+  text = text.replace(EMPHASIS, "$2");
+  text = text.replace(SINGLE_EMPHASIS, "$1");
+  return text.replace(SPACES, " ").trim();
+}
+
+/**
+ * 원문의 인라인 코드 내용이 plain 안에서 차지하는 [시작, 끝]. 앞에서부터 차례로 찾고 못 찾으면 건너뛴다.
+ * @param {string} raw
+ * @param {string} plain
+ * @returns {[number, number][]}
+ */
+export function codeSpans(raw, plain) {
+  /** @type {[number, number][]} */
+  const spans = [];
+  let cursor = 0;
+  for (const match of raw.matchAll(INLINE_CODE)) {
+    const needle = match[1].replace(SPACES, " ");
+    if (!needle) continue;
+    const at = plain.indexOf(needle, cursor);
+    if (at < 0) continue;
+    spans.push([at, at + needle.length]);
+    cursor = at + needle.length;
+  }
+  return spans;
+}