markdown-it-dl-list 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yohei Kanamura
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README-ja.md

@@ -0,0 +1,133 @@
+# markdown-it-dl-list
+
+`<dl>`, `<dt>`, `<dd>` を使った
+**コロン記法の定義リスト**をサポートする **markdown-it プラグイン**です。
+
+Pandoc などに見られる定義リスト構文に着想を得た、
+シンプルで読みやすい記法を markdown-it で利用できます。
+
+## 特徴
+
+- コロン（`:`）による定義リスト構文
+- `<dl>`, `<dt>`, `<dd>` を生成
+- 1つの用語に複数の定義を記述可能
+- 定義を持たない用語（dt-only）に対応
+- 入れ子の定義リストをサポート
+- 標準的な markdown-it の処理フローに統合可能
+
+## インストール
+
+```bash
+npm install markdown-it-dl-list
+```
+
+## 使い方
+
+```js
+import MarkdownIt from "markdown-it";
+import dlList from "markdown-it-dl-list";
+
+const md = new MarkdownIt();
+md.use(dlList);
+
+const src = `
+: 用語
+    : 説明文その1
+    : 説明文その2
+`;
+
+console.log(md.render(src));
+```
+
+出力結果：
+
+```html
+<dl>
+  <dt>用語</dt>
+  <dd>説明文その1</dd>
+  <dd>説明文その2</dd>
+</dl>
+```
+
+## 構文
+
+### 基本形
+
+```markdown
+: 用語
+    : 説明文
+```
+
+### 複数の定義
+
+```markdown
+: 用語
+    : 説明文その1
+    : 説明文その2
+```
+
+### 定義を持たない用語（dt-only）
+
+定義を持たない用語は、
+**直後が空行またはファイル末尾の場合のみ**有効です。
+
+```markdown
+: 用語のみ
+
+次の行
+```
+
+### 複数行の用語（dt 継続行）
+
+用語行の直後にインデントされた行が続く場合、
+それらは同じ用語として扱われます。
+
+```markdown
+: これは複数行の
+  用語です。
+    : これは複数行の
+      説明文です。
+```
+
+### 入れ子の定義リスト
+
+```markdown
+: 外側の用語
+    : : 内側の用語
+          : 内側の説明文
+    : 次の説明文
+```
+
+## オプション
+
+```ts
+type DlListOptions = {
+  /** dd 行に必要なインデント（スペース数）。デフォルト: 4 */
+  ddIndent?: number;
+
+  /** 定義（dd）を必須とするかどうか。デフォルト: true */
+  requireDd?: boolean;
+
+  /** 空行で現在の定義リストを終了するか。デフォルト: true */
+  breakOnBlankLine?: boolean;
+};
+```
+
+使用例：
+
+```js
+md.use(dlList, {
+  ddIndent: 2,
+  requireDd: true,
+});
+```
+
+## このプラグインが「しないこと」
+
+* 定義リスト以外の Markdown の挙動は変更しません
+* markdown-it の標準的な段落処理は維持されます
+* すべての既存定義リスト構文を網羅することは目的としていません
+
+## ライセンス
+
+MIT

package/README.md

@@ -0,0 +1,131 @@
+# markdown-it-dl-list
+
+A **markdown-it plugin** that adds support for **colon-based definition lists**
+using `<dl>`, `<dt>`, and `<dd>`.
+
+This plugin enables a simple and readable definition list syntax inspired by
+Pandoc and other Markdown variants.
+
+## Features
+
+- Colon-based definition list syntax
+- Supports `<dl>`, `<dt>`, and `<dd>`
+- Multiple definitions per term
+- Term-only entries (dt-only)
+- Nested definition lists
+- Designed to work with standard markdown-it pipelines
+
+## Installation
+
+```bash
+npm install markdown-it-dl-list
+```
+
+## Usage
+
+```js
+import MarkdownIt from "markdown-it";
+import dlList from "markdown-it-dl-list";
+
+const md = new MarkdownIt();
+md.use(dlList);
+
+const src = `
+: Term
+    : Definition line 1
+    : Definition line 2
+`;
+
+console.log(md.render(src));
+```
+
+Output:
+
+```html
+<dl>
+  <dt>Term</dt>
+  <dd>Definition line 1</dd>
+  <dd>Definition line 2</dd>
+</dl>
+```
+
+## Syntax
+
+### Basic form
+
+```markdown
+: Term
+    : Definition
+```
+
+### Multiple definitions
+
+```markdown
+: Term
+    : First definition
+    : Second definition
+```
+
+### Term-only (dt-only)
+
+A term without definitions is allowed **only when followed by a blank line or EOF**:
+
+```markdown
+: Term only
+
+Next paragraph.
+```
+
+### Multiline terms
+
+Indented lines following a term are treated as part of the term:
+
+```markdown
+: This is a
+  multiline term
+    : This is a
+      multiline definition
+```
+
+### Nested definition lists
+
+```markdown
+: Outer term
+    : : Inner term
+          : Inner definition
+    : Next definition
+```
+
+## Options
+
+```ts
+type DlListOptions = {
+  /** Indent (spaces) required for dd lines. Default: 4 */
+  ddIndent?: number;
+
+  /** Require at least one dd unless dt-only is followed by blank line or EOF. Default: true */
+  requireDd?: boolean;
+
+  /** Stop parsing the current dl at the first blank line after items. Default: true */
+  breakOnBlankLine?: boolean;
+};
+```
+
+Example:
+
+```js
+md.use(dlList, {
+  ddIndent: 2,
+  requireDd: true,
+});
+```
+
+## What this plugin does NOT do
+
+* Does not modify Markdown rendering outside definition lists
+* Does not change markdown-it default paragraph behavior
+* Does not attempt to support every existing definition list syntax variant
+
+## License
+
+MIT

package/dist/index.cjs

@@ -0,0 +1,273 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  default: () => dlListPlugin
+});
+module.exports = __toCommonJS(index_exports);
+var RULE_NAME = "dl_list_colon";
+var T_DL_OPEN = "dl_list_open";
+var T_DL_CLOSE = "dl_list_close";
+var T_DT_OPEN = "dl_dt_open";
+var T_DT_CLOSE = "dl_dt_close";
+var T_DD_OPEN = "dl_dd_open";
+var T_DD_CLOSE = "dl_dd_close";
+var DEFAULT_DD_INDENT = 4;
+var DEFAULT_REQUIRE_DD = true;
+var DEFAULT_BREAK_ON_BLANK = true;
+function dlListPlugin(md, opts = {}) {
+  const ddIndent = clampInt(opts.ddIndent ?? DEFAULT_DD_INDENT, 1, 12);
+  const requireDd = opts.requireDd ?? DEFAULT_REQUIRE_DD;
+  const breakOnBlankLine = opts.breakOnBlankLine ?? DEFAULT_BREAK_ON_BLANK;
+  md.block.ruler.before("paragraph", RULE_NAME, (state, startLine, endLine, silent) => {
+    const begin = startLine;
+    const firstDt = readDtBlock(state, begin, endLine, ddIndent);
+    if (!firstDt) return false;
+    const firstHasDd = hasDdHeaderAtSameLevel(state, firstDt, ddIndent, endLine);
+    const firstDtOnlyOk = !firstHasDd && isDtOnlyBoundary(state, firstDt.nextLine, endLine);
+    if (requireDd && !firstHasDd && !firstDtOnlyOk) return false;
+    if (silent) return true;
+    const parsed = parseDlItems(state, begin, endLine, { ddIndent, requireDd, breakOnBlankLine });
+    if (!parsed) return false;
+    renderDlTokens(state, begin, parsed.endLine, parsed.items);
+    state.line = parsed.endLine;
+    return true;
+  });
+  md.renderer.rules[T_DL_OPEN] = () => "<dl>\n";
+  md.renderer.rules[T_DL_CLOSE] = () => "</dl>\n";
+  md.renderer.rules[T_DT_OPEN] = () => "<dt>";
+  md.renderer.rules[T_DT_CLOSE] = () => "</dt>\n";
+  md.renderer.rules[T_DD_OPEN] = () => "<dd>";
+  md.renderer.rules[T_DD_CLOSE] = () => "</dd>\n";
+}
+function parseDlItems(state, begin, endLine, ctx) {
+  const items = [];
+  let line = begin;
+  while (line < endLine) {
+    const dtBlock = readDtBlock(state, line, endLine, ctx.ddIndent);
+    if (!dtBlock) break;
+    const { dds, nextLineAfterDds } = collectDds(state, dtBlock, endLine, ctx.ddIndent);
+    if (dds.length === 0) {
+      const afterDt = dtBlock.nextLine;
+      const dtOnlyHere = isDtOnlyBoundary(state, afterDt, endLine);
+      if (ctx.requireDd && !dtOnlyHere) break;
+      items.push({ dtLine: line, dtText: dtBlock.text, dds: [] });
+      line = afterDt;
+      break;
+    }
+    items.push({ dtLine: line, dtText: dtBlock.text, dds });
+    line = nextLineAfterDds;
+    if (ctx.breakOnBlankLine && line < endLine && isBlankLine(state, line)) break;
+  }
+  if (items.length === 0) return null;
+  return { items, endLine: line };
+}
+function renderDlTokens(state, begin, endLine, items) {
+  const dlOpen = state.push(T_DL_OPEN, "dl", 1);
+  dlOpen.map = [begin, endLine];
+  for (const it of items) {
+    const dtOpen = state.push(T_DT_OPEN, "dt", 1);
+    dtOpen.map = [it.dtLine, it.dtLine + 1];
+    pushInline(state, it.dtText, it.dtLine);
+    state.push(T_DT_CLOSE, "dt", -1);
+    for (const d of it.dds) {
+      state.push(T_DD_OPEN, "dd", 1);
+      if (shouldBlockParseDd(d.text)) {
+        const ddText = looksLikeNestedDl(d.text) ? normalizeNestedDlText(d.text) : d.text;
+        const normalized = normalizeIndentedBlock(ddText);
+        parseDdContentIntoTokens(state, normalized);
+      } else {
+        pushInline(state, d.text, d.line);
+      }
+      state.push(T_DD_CLOSE, "dd", -1);
+    }
+  }
+  state.push(T_DL_CLOSE, "dl", -1);
+}
+function collectDds(state, dtBlock, endLine, ddIndent) {
+  const dds = [];
+  let next = dtBlock.nextLine;
+  while (next < endLine) {
+    if (isBlankLine(state, next)) break;
+    const ddBlock = readDdBlock(state, next, endLine, dtBlock.baseIndent, ddIndent);
+    if (!ddBlock) break;
+    dds.push({ line: next, text: ddBlock.text });
+    next = ddBlock.nextLine;
+  }
+  return { dds, nextLineAfterDds: next };
+}
+function hasDdHeaderAtSameLevel(state, dtBlock, ddIndent, endLine) {
+  const minIndent = dtBlock.baseIndent + ddIndent;
+  if (dtBlock.nextLine >= endLine) return false;
+  return !!parseDdHeaderAtLevel(state, dtBlock.nextLine, minIndent) || isEmptyDdHeaderAtLevel(state, dtBlock.nextLine, minIndent);
+}
+function isDtOnlyBoundary(state, line, endLine) {
+  return line >= endLine || isBlankLine(state, line);
+}
+function shouldBlockParseDd(text) {
+  return looksLikeNestedDl(text) || text.indexOf("\n") >= 0;
+}
+function looksLikeNestedDl(text) {
+  return text.replace(/^\s+/, "").indexOf(":") === 0;
+}
+function pushInline(state, text, line) {
+  const token = state.push("inline", "", 0);
+  token.map = [line, line + 1];
+  token.content = text;
+  token.children = [];
+}
+function isBlankLine(state, line) {
+  const start = state.bMarks[line] + state.tShift[line];
+  const end = state.eMarks[line];
+  return start >= end;
+}
+function parseDtLine(state, line) {
+  if (line >= state.lineMax) return null;
+  const raw = getLineText(state, line);
+  const m = raw.match(/^( {0,3}):[ \t]+(.+?)\s*$/);
+  return m ? { text: m[2] } : null;
+}
+function parseDdHeaderAtLevel(state, line, minIndent) {
+  if (line >= state.lineMax) return null;
+  const raw = getLineText(state, line);
+  const indent = countLeadingSpaces(raw);
+  if (indent < minIndent || indent > minIndent + 3) return null;
+  const re = new RegExp(`^( {${indent}})(::?)[ \\t]+(.+?)\\s*$`);
+  const m = raw.match(re);
+  if (!m) return null;
+  const marker = m[2];
+  return { text: m[3], isNestedDlStart: marker === "::" };
+}
+function isEmptyDdHeaderAtLevel(state, line, minIndent) {
+  if (line >= state.lineMax) return false;
+  const raw = getLineText(state, line);
+  const indent = countLeadingSpaces(raw);
+  if (indent < minIndent || indent > minIndent + 3) return false;
+  const re = new RegExp(`^( {${indent}})(::?)\\s*$`);
+  return re.test(raw);
+}
+function readDtBlock(state, startLine, endLine, ddMinIndent) {
+  const dt = parseDtLine(state, startLine);
+  if (!dt) return null;
+  const raw0 = getLineText(state, startLine);
+  const baseIndent = countLeadingSpaces(raw0);
+  const lines = [dt.text];
+  let line = startLine + 1;
+  while (line < endLine) {
+    if (isWhitespaceOnlyLine(state, line)) break;
+    if (parseDtLine(state, line)) break;
+    const minIndent = baseIndent + ddMinIndent;
+    if (parseDdHeaderAtLevel(state, line, minIndent) || isEmptyDdHeaderAtLevel(state, line, minIndent)) break;
+    const raw = getLineText(state, line);
+    const first = raw.charCodeAt(0);
+    const isSpaceOrTab = first === 32 || first === 9;
+    if (!isSpaceOrTab) break;
+    lines.push(stripUpTo(raw, baseIndent + 2).replace(/\s+$/, ""));
+    line++;
+  }
+  return { baseIndent, text: lines.join("\n"), nextLine: line };
+}
+function readDdBlock(state, startLine, endLine, baseIndent, ddIndent) {
+  const minIndent = baseIndent + ddIndent;
+  const dd0 = parseDdHeaderAtLevel(state, startLine, minIndent);
+  const emptyHeader = !dd0 && isEmptyDdHeaderAtLevel(state, startLine, minIndent);
+  if (!dd0 && !emptyHeader) return null;
+  const lines = [];
+  if (dd0) {
+    lines.push(dd0.isNestedDlStart ? `: ${dd0.text}` : dd0.text);
+  }
+  let line = startLine + 1;
+  while (line < endLine) {
+    if (isWhitespaceOnlyLine(state, line)) {
+      const next = line + 1;
+      if (next >= endLine) break;
+      if (isWhitespaceOnlyLine(state, next)) break;
+      if (parseDtLine(state, next)) break;
+      if (parseDdHeaderAtLevel(state, next, minIndent) || isEmptyDdHeaderAtLevel(state, next, minIndent)) break;
+      const rawNext = getLineText(state, next);
+      const indentNext = countLeadingSpaces(rawNext);
+      if (!emptyHeader && indentNext < minIndent) break;
+      lines.push("");
+      line++;
+      continue;
+    }
+    if (parseDtLine(state, line)) break;
+    if (parseDdHeaderAtLevel(state, line, minIndent) || isEmptyDdHeaderAtLevel(state, line, minIndent)) break;
+    const raw = getLineText(state, line);
+    const indent = countLeadingSpaces(raw);
+    if (!emptyHeader && indent < minIndent) break;
+    const cut = emptyHeader ? Math.min(indent, minIndent) : minIndent;
+    lines.push(stripUpTo(raw, cut).replace(/\s+$/, ""));
+    line++;
+  }
+  return { text: lines.length === 0 ? "" : lines.join("\n"), nextLine: line };
+}
+function getLineText(state, line) {
+  const start = state.bMarks[line];
+  const end = state.eMarks[line];
+  return state.src.slice(start, end);
+}
+function isWhitespaceOnlyLine(state, line) {
+  return getLineText(state, line).trim().length === 0;
+}
+function countLeadingSpaces(s) {
+  let i = 0;
+  while (i < s.length && s.charCodeAt(i) === 32) i++;
+  return i;
+}
+function stripUpTo(s, n) {
+  let i = 0;
+  while (i < s.length && i < n && s.charCodeAt(i) === 32) i++;
+  return s.slice(i);
+}
+function clampInt(n, min, max) {
+  if (typeof n !== "number" || !isFinite(n)) return min;
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function normalizeNestedDlText(text) {
+  const lines = text.split("\n");
+  if (lines.length <= 1) return text;
+  for (let i = 1; i < lines.length; i++) {
+    const m = lines[i].match(/^(\s*):(.*)$/);
+    if (m) lines[i] = "    :" + m[2];
+  }
+  return lines.join("\n");
+}
+function normalizeIndentedBlock(text) {
+  const lines = text.split("\n");
+  let min = Infinity;
+  for (const l of lines) {
+    if (l.trim().length === 0) continue;
+    const n = countLeadingSpaces(l);
+    if (n < min) min = n;
+  }
+  if (!isFinite(min) || min === 0) return text;
+  return lines.map((l) => l.trim().length === 0 ? "" : stripUpTo(l, min)).join("\n");
+}
+function parseDdContentIntoTokens(state, text) {
+  var _a, _b, _c;
+  const start = state.tokens.length;
+  state.md.block.parse(text, state.md, state.env, state.tokens);
+  const added = state.tokens.slice(start);
+  if (added.length === 3 && ((_a = added[0]) == null ? void 0 : _a.type) === "paragraph_open" && ((_b = added[1]) == null ? void 0 : _b.type) === "inline" && ((_c = added[2]) == null ? void 0 : _c.type) === "paragraph_close") {
+    state.tokens.length = start;
+    state.tokens.push(added[1]);
+  }
+}

package/dist/index.d.cts

@@ -0,0 +1,16 @@
+import MarkdownIt from 'markdown-it';
+
+/**
+ * Options for the colon-based definition list plugin.
+ */
+type DlListOptions = {
+    /** Indent (spaces) required for dd lines. Default: 4 */
+    ddIndent?: number;
+    /** If true, dt-only items are allowed only when followed by blank line or EOF. Default: true */
+    requireDd?: boolean;
+    /** If true, stop parsing the current dl at the first blank line after items. Default: true */
+    breakOnBlankLine?: boolean;
+};
+declare function dlListPlugin(md: MarkdownIt, opts?: DlListOptions): void;
+
+export { type DlListOptions, dlListPlugin as default };

package/dist/index.d.ts

@@ -0,0 +1,16 @@
+import MarkdownIt from 'markdown-it';
+
+/**
+ * Options for the colon-based definition list plugin.
+ */
+type DlListOptions = {
+    /** Indent (spaces) required for dd lines. Default: 4 */
+    ddIndent?: number;
+    /** If true, dt-only items are allowed only when followed by blank line or EOF. Default: true */
+    requireDd?: boolean;
+    /** If true, stop parsing the current dl at the first blank line after items. Default: true */
+    breakOnBlankLine?: boolean;
+};
+declare function dlListPlugin(md: MarkdownIt, opts?: DlListOptions): void;
+
+export { type DlListOptions, dlListPlugin as default };

package/dist/index.js

@@ -0,0 +1,253 @@
+// src/index.ts
+var RULE_NAME = "dl_list_colon";
+var T_DL_OPEN = "dl_list_open";
+var T_DL_CLOSE = "dl_list_close";
+var T_DT_OPEN = "dl_dt_open";
+var T_DT_CLOSE = "dl_dt_close";
+var T_DD_OPEN = "dl_dd_open";
+var T_DD_CLOSE = "dl_dd_close";
+var DEFAULT_DD_INDENT = 4;
+var DEFAULT_REQUIRE_DD = true;
+var DEFAULT_BREAK_ON_BLANK = true;
+function dlListPlugin(md, opts = {}) {
+  const ddIndent = clampInt(opts.ddIndent ?? DEFAULT_DD_INDENT, 1, 12);
+  const requireDd = opts.requireDd ?? DEFAULT_REQUIRE_DD;
+  const breakOnBlankLine = opts.breakOnBlankLine ?? DEFAULT_BREAK_ON_BLANK;
+  md.block.ruler.before("paragraph", RULE_NAME, (state, startLine, endLine, silent) => {
+    const begin = startLine;
+    const firstDt = readDtBlock(state, begin, endLine, ddIndent);
+    if (!firstDt) return false;
+    const firstHasDd = hasDdHeaderAtSameLevel(state, firstDt, ddIndent, endLine);
+    const firstDtOnlyOk = !firstHasDd && isDtOnlyBoundary(state, firstDt.nextLine, endLine);
+    if (requireDd && !firstHasDd && !firstDtOnlyOk) return false;
+    if (silent) return true;
+    const parsed = parseDlItems(state, begin, endLine, { ddIndent, requireDd, breakOnBlankLine });
+    if (!parsed) return false;
+    renderDlTokens(state, begin, parsed.endLine, parsed.items);
+    state.line = parsed.endLine;
+    return true;
+  });
+  md.renderer.rules[T_DL_OPEN] = () => "<dl>\n";
+  md.renderer.rules[T_DL_CLOSE] = () => "</dl>\n";
+  md.renderer.rules[T_DT_OPEN] = () => "<dt>";
+  md.renderer.rules[T_DT_CLOSE] = () => "</dt>\n";
+  md.renderer.rules[T_DD_OPEN] = () => "<dd>";
+  md.renderer.rules[T_DD_CLOSE] = () => "</dd>\n";
+}
+function parseDlItems(state, begin, endLine, ctx) {
+  const items = [];
+  let line = begin;
+  while (line < endLine) {
+    const dtBlock = readDtBlock(state, line, endLine, ctx.ddIndent);
+    if (!dtBlock) break;
+    const { dds, nextLineAfterDds } = collectDds(state, dtBlock, endLine, ctx.ddIndent);
+    if (dds.length === 0) {
+      const afterDt = dtBlock.nextLine;
+      const dtOnlyHere = isDtOnlyBoundary(state, afterDt, endLine);
+      if (ctx.requireDd && !dtOnlyHere) break;
+      items.push({ dtLine: line, dtText: dtBlock.text, dds: [] });
+      line = afterDt;
+      break;
+    }
+    items.push({ dtLine: line, dtText: dtBlock.text, dds });
+    line = nextLineAfterDds;
+    if (ctx.breakOnBlankLine && line < endLine && isBlankLine(state, line)) break;
+  }
+  if (items.length === 0) return null;
+  return { items, endLine: line };
+}
+function renderDlTokens(state, begin, endLine, items) {
+  const dlOpen = state.push(T_DL_OPEN, "dl", 1);
+  dlOpen.map = [begin, endLine];
+  for (const it of items) {
+    const dtOpen = state.push(T_DT_OPEN, "dt", 1);
+    dtOpen.map = [it.dtLine, it.dtLine + 1];
+    pushInline(state, it.dtText, it.dtLine);
+    state.push(T_DT_CLOSE, "dt", -1);
+    for (const d of it.dds) {
+      state.push(T_DD_OPEN, "dd", 1);
+      if (shouldBlockParseDd(d.text)) {
+        const ddText = looksLikeNestedDl(d.text) ? normalizeNestedDlText(d.text) : d.text;
+        const normalized = normalizeIndentedBlock(ddText);
+        parseDdContentIntoTokens(state, normalized);
+      } else {
+        pushInline(state, d.text, d.line);
+      }
+      state.push(T_DD_CLOSE, "dd", -1);
+    }
+  }
+  state.push(T_DL_CLOSE, "dl", -1);
+}
+function collectDds(state, dtBlock, endLine, ddIndent) {
+  const dds = [];
+  let next = dtBlock.nextLine;
+  while (next < endLine) {
+    if (isBlankLine(state, next)) break;
+    const ddBlock = readDdBlock(state, next, endLine, dtBlock.baseIndent, ddIndent);
+    if (!ddBlock) break;
+    dds.push({ line: next, text: ddBlock.text });
+    next = ddBlock.nextLine;
+  }
+  return { dds, nextLineAfterDds: next };
+}
+function hasDdHeaderAtSameLevel(state, dtBlock, ddIndent, endLine) {
+  const minIndent = dtBlock.baseIndent + ddIndent;
+  if (dtBlock.nextLine >= endLine) return false;
+  return !!parseDdHeaderAtLevel(state, dtBlock.nextLine, minIndent) || isEmptyDdHeaderAtLevel(state, dtBlock.nextLine, minIndent);
+}
+function isDtOnlyBoundary(state, line, endLine) {
+  return line >= endLine || isBlankLine(state, line);
+}
+function shouldBlockParseDd(text) {
+  return looksLikeNestedDl(text) || text.indexOf("\n") >= 0;
+}
+function looksLikeNestedDl(text) {
+  return text.replace(/^\s+/, "").indexOf(":") === 0;
+}
+function pushInline(state, text, line) {
+  const token = state.push("inline", "", 0);
+  token.map = [line, line + 1];
+  token.content = text;
+  token.children = [];
+}
+function isBlankLine(state, line) {
+  const start = state.bMarks[line] + state.tShift[line];
+  const end = state.eMarks[line];
+  return start >= end;
+}
+function parseDtLine(state, line) {
+  if (line >= state.lineMax) return null;
+  const raw = getLineText(state, line);
+  const m = raw.match(/^( {0,3}):[ \t]+(.+?)\s*$/);
+  return m ? { text: m[2] } : null;
+}
+function parseDdHeaderAtLevel(state, line, minIndent) {
+  if (line >= state.lineMax) return null;
+  const raw = getLineText(state, line);
+  const indent = countLeadingSpaces(raw);
+  if (indent < minIndent || indent > minIndent + 3) return null;
+  const re = new RegExp(`^( {${indent}})(::?)[ \\t]+(.+?)\\s*$`);
+  const m = raw.match(re);
+  if (!m) return null;
+  const marker = m[2];
+  return { text: m[3], isNestedDlStart: marker === "::" };
+}
+function isEmptyDdHeaderAtLevel(state, line, minIndent) {
+  if (line >= state.lineMax) return false;
+  const raw = getLineText(state, line);
+  const indent = countLeadingSpaces(raw);
+  if (indent < minIndent || indent > minIndent + 3) return false;
+  const re = new RegExp(`^( {${indent}})(::?)\\s*$`);
+  return re.test(raw);
+}
+function readDtBlock(state, startLine, endLine, ddMinIndent) {
+  const dt = parseDtLine(state, startLine);
+  if (!dt) return null;
+  const raw0 = getLineText(state, startLine);
+  const baseIndent = countLeadingSpaces(raw0);
+  const lines = [dt.text];
+  let line = startLine + 1;
+  while (line < endLine) {
+    if (isWhitespaceOnlyLine(state, line)) break;
+    if (parseDtLine(state, line)) break;
+    const minIndent = baseIndent + ddMinIndent;
+    if (parseDdHeaderAtLevel(state, line, minIndent) || isEmptyDdHeaderAtLevel(state, line, minIndent)) break;
+    const raw = getLineText(state, line);
+    const first = raw.charCodeAt(0);
+    const isSpaceOrTab = first === 32 || first === 9;
+    if (!isSpaceOrTab) break;
+    lines.push(stripUpTo(raw, baseIndent + 2).replace(/\s+$/, ""));
+    line++;
+  }
+  return { baseIndent, text: lines.join("\n"), nextLine: line };
+}
+function readDdBlock(state, startLine, endLine, baseIndent, ddIndent) {
+  const minIndent = baseIndent + ddIndent;
+  const dd0 = parseDdHeaderAtLevel(state, startLine, minIndent);
+  const emptyHeader = !dd0 && isEmptyDdHeaderAtLevel(state, startLine, minIndent);
+  if (!dd0 && !emptyHeader) return null;
+  const lines = [];
+  if (dd0) {
+    lines.push(dd0.isNestedDlStart ? `: ${dd0.text}` : dd0.text);
+  }
+  let line = startLine + 1;
+  while (line < endLine) {
+    if (isWhitespaceOnlyLine(state, line)) {
+      const next = line + 1;
+      if (next >= endLine) break;
+      if (isWhitespaceOnlyLine(state, next)) break;
+      if (parseDtLine(state, next)) break;
+      if (parseDdHeaderAtLevel(state, next, minIndent) || isEmptyDdHeaderAtLevel(state, next, minIndent)) break;
+      const rawNext = getLineText(state, next);
+      const indentNext = countLeadingSpaces(rawNext);
+      if (!emptyHeader && indentNext < minIndent) break;
+      lines.push("");
+      line++;
+      continue;
+    }
+    if (parseDtLine(state, line)) break;
+    if (parseDdHeaderAtLevel(state, line, minIndent) || isEmptyDdHeaderAtLevel(state, line, minIndent)) break;
+    const raw = getLineText(state, line);
+    const indent = countLeadingSpaces(raw);
+    if (!emptyHeader && indent < minIndent) break;
+    const cut = emptyHeader ? Math.min(indent, minIndent) : minIndent;
+    lines.push(stripUpTo(raw, cut).replace(/\s+$/, ""));
+    line++;
+  }
+  return { text: lines.length === 0 ? "" : lines.join("\n"), nextLine: line };
+}
+function getLineText(state, line) {
+  const start = state.bMarks[line];
+  const end = state.eMarks[line];
+  return state.src.slice(start, end);
+}
+function isWhitespaceOnlyLine(state, line) {
+  return getLineText(state, line).trim().length === 0;
+}
+function countLeadingSpaces(s) {
+  let i = 0;
+  while (i < s.length && s.charCodeAt(i) === 32) i++;
+  return i;
+}
+function stripUpTo(s, n) {
+  let i = 0;
+  while (i < s.length && i < n && s.charCodeAt(i) === 32) i++;
+  return s.slice(i);
+}
+function clampInt(n, min, max) {
+  if (typeof n !== "number" || !isFinite(n)) return min;
+  return Math.max(min, Math.min(max, Math.floor(n)));
+}
+function normalizeNestedDlText(text) {
+  const lines = text.split("\n");
+  if (lines.length <= 1) return text;
+  for (let i = 1; i < lines.length; i++) {
+    const m = lines[i].match(/^(\s*):(.*)$/);
+    if (m) lines[i] = "    :" + m[2];
+  }
+  return lines.join("\n");
+}
+function normalizeIndentedBlock(text) {
+  const lines = text.split("\n");
+  let min = Infinity;
+  for (const l of lines) {
+    if (l.trim().length === 0) continue;
+    const n = countLeadingSpaces(l);
+    if (n < min) min = n;
+  }
+  if (!isFinite(min) || min === 0) return text;
+  return lines.map((l) => l.trim().length === 0 ? "" : stripUpTo(l, min)).join("\n");
+}
+function parseDdContentIntoTokens(state, text) {
+  var _a, _b, _c;
+  const start = state.tokens.length;
+  state.md.block.parse(text, state.md, state.env, state.tokens);
+  const added = state.tokens.slice(start);
+  if (added.length === 3 && ((_a = added[0]) == null ? void 0 : _a.type) === "paragraph_open" && ((_b = added[1]) == null ? void 0 : _b.type) === "inline" && ((_c = added[2]) == null ? void 0 : _c.type) === "paragraph_close") {
+    state.tokens.length = start;
+    state.tokens.push(added[1]);
+  }
+}
+export {
+  dlListPlugin as default
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "markdown-it-dl-list",
+  "version": "0.1.0",
+  "description": "markdown-it plugin for colon-based definition lists (<dl>, <dt>, <dd>)",
+  "license": "MIT",
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kanemu/dl-list-markdown"
+  },
+  "homepage": "https://github.com/kanemu/dl-list-markdown/tree/main/packages/markdown-it-dl-list",
+  "bugs": {
+    "url": "https://github.com/kanemu/dl-list-markdown/issues"
+  },
+  "keywords": [
+    "markdown-it",
+    "markdown",
+    "definition-list",
+    "dl",
+    "dt",
+    "dd",
+    "plugin"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "require": "./dist/index.cjs"
+    }
+  },
+  "main": "./dist/index.cjs",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**",
+    "README.md",
+    "README-ja.md",
+    "LICENSE"
+  ],
+  "sideEffects": false,
+  "peerDependencies": {
+    "markdown-it": "^14.0.0"
+  },
+  "peerDependenciesMeta": {
+    "markdown-it": {
+      "optional": false
+    }
+  },
+  "devDependencies": {
+    "@types/markdown-it": "^14.1.2",
+    "markdown-it": "^14.1.0",
+    "rimraf": "^6.1.2",
+    "tsup": "^8.5.1",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.17"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm,cjs --dts --clean",
+    "test": "vitest run",
+    "dev": "vitest",
+    "clean": "rimraf dist"
+  }
+}