micromark-extension-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.md

@@ -0,0 +1,79 @@
+# micromark-extension-dl-list
+
+A **micromark extension** that adds colon-based definition list syntax.
+
+This package provides **syntax only** and is intended to be used with
+remark or other unified pipelines.
+
+For the detailed definition list syntax,  
+→ **[docs/syntax.md](https://github.com/kanemu/unified-dl-list/blob/main/docs/syntax.md)**.
+
+## Installation
+
+```bash
+npm install micromark-extension-dl-list
+````
+
+or with pnpm:
+
+```bash
+pnpm add micromark-extension-dl-list
+```
+
+## Usage
+
+### With micromark (HTML output)
+
+This package can be used directly with `micromark`
+to parse colon-based definition lists and generate
+`<dl>`, `<dt>`, and `<dd>` elements.
+
+```js
+import { micromark } from 'micromark'
+import { dlList, dlListHtml } from 'micromark-extension-dl-list'
+
+const md = `
+: term
+    : description
+    : another description
+`
+
+const html = micromark(md, {
+  extensions: [dlList()],
+  htmlExtensions: [dlListHtml()]
+})
+
+console.log(html)
+```
+
+Output:
+
+```html
+<dl>
+  <dt>term</dt>
+  <dd>description</dd>
+  <dd>another description</dd>
+</dl>
+```
+
+## What this package does
+
+* Adds colon-based definition list syntax to micromark
+* Emits tokens for `<dl>`, `<dt>`, and `<dd>`
+
+## What this package does NOT do
+
+- Does not generate mdast nodes
+- Does not provide a remark plugin
+
+## Related packages
+
+This package is part of the **[unified-dl-list](https://github.com/kanemu/unified-dl-list)** monorepo:
+
+- [`remark-dl-list`](https://github.com/kanemu/unified-dl-list/tree/main/packages/remark-dl-list)
+- [`mdast-util-dl-list`](https://github.com/kanemu/unified-dl-list/tree/main/packages/mdast-util-dl-list)
+- [`hast-util-dl-list`](https://github.com/kanemu/unified-dl-list/tree/main/packages/hast-util-dl-list)
+
+## License
+
+MIT

package/package.json

@@ -0,0 +1,54 @@
+{
+  "name": "micromark-extension-dl-list",
+  "version": "0.1.0",
+  "description": "A micromark extension that adds colon-based definition list (<dl>, <dt>, <dd>) support with CommonMark-compatible parsing rules.",
+  "type": "module",
+  "sideEffects": false,
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/kanemu/unified-dl-list",
+    "directory": "packages/micromark-extension-dl-list"
+  },
+  "homepage": "https://github.com/kanemu/unified-dl-list/tree/main/packages/micromark-extension-dl-list",
+  "bugs": {
+    "url": "https://github.com/kanemu/unified-dl-list/issues"
+  },
+  "exports": {
+    ".": {
+      "types": "./src/index.d.ts",
+      "import": "./src/index.js"
+    },
+    "./syntax.js": {
+      "import": "./src/syntax.js"
+    },
+    "./html.js": {
+      "import": "./src/html.js"
+    }
+  },
+  "files": [
+    "src/**/*.js",
+    "src/**/*.d.ts",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "micromark": "^4.0.2",
+    "micromark-util-character": "^2.1.1",
+    "micromark-util-symbol": "^2.0.1"
+  },
+  "keywords": [
+    "micromark",
+    "micromark-extension",
+    "markdown",
+    "definition-list",
+    "dl",
+    "dt",
+    "dd",
+    "commonmark"
+  ],
+  "author": "Yohei Kanamura",
+  "license": "MIT",
+  "scripts": {
+    "test": "node --test ./test/*.test.js"
+  }
+}

package/src/constants.js

@@ -0,0 +1,17 @@
+/**
+ * Tab width used for column calculation.
+ * CommonMark / micromark treat a tab stop as 4 columns in indentation contexts.
+ *
+ * @type {number}
+ */
+export const TAB_SIZE = 4
+
+/**
+ * Upper bound (exclusive) of indentation columns allowed before `:` to start a dl-list construct.
+ *
+ * - CommonMark list rule allows up to 3 columns of indentation (0–3).
+ * - We keep it as an exclusive upper bound so callers can write `col < MAX_PREFIX_COLS`.
+ *
+ * @type {number}
+ */
+export const MAX_PREFIX_COLS = 4

package/src/html.js

@@ -0,0 +1,207 @@
+import { micromark } from 'micromark'
+import { dlList } from './syntax.js'
+
+/**
+ * @typedef {import('micromark-util-types').HtmlExtension} HtmlExtension
+ */
+
+/**
+ * @typedef {object} DlListHtmlOptions
+ * @property {number} [maxDepth] Maximum recursion depth for nested dl parsing inside dd containers.
+ */
+
+function deindentByColumns(raw, cols) {
+    if (!cols) return raw
+
+    const text = raw.replace(/\r\n?/g, '\n')
+    const lines = text.split('\n')
+
+    return lines
+        .map((line) => {
+            let col = 0
+            let i = 0
+
+            while (i < line.length && col < cols) {
+                const ch = line.charCodeAt(i)
+
+                if (ch === 0x20) {
+                    col += 1
+                    i += 1
+                    continue
+                }
+
+                if (ch === 0x09) {
+                    const r = col % 4
+                    const step = r === 0 ? 4 : 4 - r
+                    if (col + step > cols) break
+                    col += step
+                    i += 1
+                    continue
+                }
+
+                break
+            }
+
+            return line.slice(i)
+        })
+        .join('\n')
+}
+
+function isListMarkerLine(line) {
+    return /^([-*]|\d+\.)\s/.test(line)
+}
+
+function normalizeFlatListIndentInDd(raw) {
+    const text = raw.replace(/\r\n?/g, '\n')
+    const lines = text.split('\n')
+
+    let firstIdx = -1
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() !== '') {
+            firstIdx = i
+            break
+        }
+    }
+    if (firstIdx === -1) return raw
+
+    const first = lines[firstIdx]
+    if (!isListMarkerLine(first)) return raw
+
+    for (let i = firstIdx + 1; i < lines.length; i++) {
+        const line = lines[i]
+        if (line.startsWith('  ') && isListMarkerLine(line.slice(2))) {
+            lines[i] = line.slice(2)
+        }
+    }
+
+    return lines.join('\n')
+}
+
+function normalizeNestedDlIndentInDd(raw) {
+    const text = raw.replace(/\r\n?/g, '\n')
+    const lines = text.split('\n')
+
+    let firstIdx = -1
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim() !== '') {
+            firstIdx = i
+            break
+        }
+    }
+    if (firstIdx === -1) return raw
+    if (!lines[firstIdx].startsWith(':')) return raw
+
+    for (let i = firstIdx + 1; i < lines.length; i++) {
+        const line = lines[i]
+        if (!line.startsWith('  ')) continue
+
+        let n = 0
+        while (n < line.length && line.charCodeAt(n) === 0x20) n++
+
+        if (n >= 2 && line.charCodeAt(n) === 0x3a && (n - 2) % 4 === 0) {
+            lines[i] = line.slice(2)
+        }
+    }
+
+    return lines.join('\n')
+}
+
+function renderInlineMarkdown(raw) {
+    let html = micromark(raw)
+    const m = html.match(/^<p>([\s\S]*)<\/p>\n?$/)
+    if (m) return m[1]
+    return html
+}
+
+/**
+ * HTML extension for dl-list tokens.
+ *
+ * - `dlTermText` is rendered as inline markdown.
+ * - `dlDescContainer` is deindented and re-parsed as block markdown (with nested dl support).
+ *
+ * @param {DlListHtmlOptions=} options
+ * @returns {HtmlExtension}
+ */
+export function dlListHtml(options = {}) {
+    const maxDepth = options.maxDepth ?? 8
+
+    /** @type {HtmlExtension} */
+    return {
+        enter: {
+            dlList() {
+                this.tag('<dl>')
+            },
+
+            dlItem() { },
+
+            dlTerm() {
+                this.tag('<dt>')
+            },
+            dlDesc() {
+                this.tag('<dd>')
+            },
+
+            dlIndent() { },
+            dlMarkerSpace() { },
+            dlLineEnding() { },
+
+            dlHardBreak() {
+                this.raw('\n')
+            },
+
+            dlTermText() { },
+
+            dlDescContainer() { }
+        },
+
+        exit: {
+            dlList() {
+                this.tag('</dl>')
+            },
+
+            dlItem() { },
+
+            dlTerm() {
+                this.tag('</dt>')
+            },
+            dlDesc() {
+                this.tag('</dd>')
+            },
+
+            dlTermText(token) {
+                const raw = this.sliceSerialize(token)
+                this.raw(renderInlineMarkdown(raw))
+            },
+
+            dlIndent() { },
+            dlMarkerSpace() { },
+            dlLineEnding() { },
+
+            dlDescContainer(token) {
+                let raw = this.sliceSerialize(token)
+                raw = deindentByColumns(raw, token._dlIndent || 0)
+                raw = normalizeFlatListIndentInDd(raw)
+                raw = normalizeNestedDlIndentInDd(raw)
+
+                if (maxDepth <= 0) {
+                    this.raw(micromark(raw))
+                    return
+                }
+
+                const html = micromark(raw, {
+                    extensions: [dlList()],
+                    htmlExtensions: [dlListHtml({ maxDepth: maxDepth - 1 })]
+                })
+
+                const trimmed = html.replace(/^\s+|\s+$/g, '')
+                const m = trimmed.match(/^<p>([\s\S]*)<\/p>$/)
+                if (m) {
+                    this.raw(m[1])
+                    return
+                }
+
+                this.raw(html)
+            }
+        }
+    }
+}

package/src/index.d.ts

@@ -0,0 +1,9 @@
+import type { Extension, HtmlExtension } from "micromark-util-types";
+
+export function dlList(): Extension;
+
+export type DlListHtmlOptions = {
+    maxDepth?: number;
+};
+
+export function dlListHtml(options?: DlListHtmlOptions): HtmlExtension;

package/src/index.js

@@ -0,0 +1,2 @@
+export { dlList } from './syntax.js'
+export { dlListHtml } from './html.js'

package/src/lookahead.js

@@ -0,0 +1,169 @@
+import { markdownLineEnding } from 'micromark-util-character'
+import { codes } from 'micromark-util-symbol'
+import { MAX_PREFIX_COLS } from './constants.js'
+import { isEof, isIndent, consumeSafe, advanceColumn } from './util.js'
+
+/**
+ * Lookahead tokenizers used by dl-list to confirm start / continuation without consuming input.
+ *
+ * These are separated from tokenize.js to keep the main tokenizer readable.
+ */
+
+/**
+ * Check whether the current line can start dl-list after optional indentation (<= 3 cols).
+ * Succeeds when it can reach ':' before exceeding MAX_PREFIX_COLS.
+ */
+export function checkPrefixFactory() {
+    return {
+        tokenize(effects2, ok2, nok2) {
+            let col = 0
+            return start2
+
+            /** @type {import('micromark-util-types').State} */
+            function start2(code) {
+                if (isEof(code)) return nok2(code)
+                if (code === codes.colon) return ok2(code)
+
+                if (isIndent(code) && col < MAX_PREFIX_COLS) {
+                    col = advanceColumn(col, code)
+                    consumeSafe(effects2, code)
+                    if (col > MAX_PREFIX_COLS) return nok2(code)
+                    return start2
+                }
+
+                return nok2(code)
+            }
+        }
+    }
+}
+
+/**
+ * Check whether the dl-list should continue after a line ending.
+ *
+ * - ok when next line begins with ':' or indentation
+ * - stop on blank line (do not consume blank-line EOL in the main tokenizer)
+ */
+export function checkAfterEolContinueFactory() {
+    return {
+        tokenize(effects2, ok2, nok2) {
+            let opened = false
+            return start2
+
+            function start2(code) {
+                if (isEof(code)) return ok2(code)
+                if (!markdownLineEnding(code)) return nok2(code)
+
+                effects2.enter('dlCheck')
+                opened = true
+
+                // consume the line ending so we can inspect the next line head
+                effects2.consume(code)
+                return head
+            }
+
+            function head(code) {
+                if (isEof(code)) return endOk(code)
+                if (markdownLineEnding(code)) return endNok(code) // blank line -> stop
+                if (code === codes.colon) return endOk(code)
+                if (isIndent(code)) return endOk(code)
+                return endNok(code)
+            }
+
+            function endOk(code) {
+                if (opened) {
+                    effects2.exit('dlCheck')
+                    opened = false
+                }
+                return ok2(code)
+            }
+
+            function endNok(code) {
+                if (opened) {
+                    effects2.exit('dlCheck')
+                    opened = false
+                }
+                return nok2(code)
+            }
+        }
+    }
+}
+
+/**
+ * Check whether a ':' at baseIndent can start a dl-list.
+ *
+ * Requires:
+ * - the ':' line itself exists
+ * - next line is EOF or blank, OR
+ * - next line begins with ':' at baseIndent or ddIndent, OR
+ * - next line is indented beyond baseIndent (continuation for dt)
+ */
+export function checkDlStartFactory(baseIndentArg, ddIndentArg) {
+    return {
+        tokenize(effects2, ok2, nok2) {
+            let col = 0
+            let opened = false
+            return start2
+
+            function start2(code) {
+                if (isEof(code)) return nok2(code)
+                if (code !== codes.colon) return nok2(code)
+
+                effects2.enter('dlCheck')
+                opened = true
+
+                effects2.consume(code) // ':'
+                return restOfLine
+            }
+
+            function restOfLine(code) {
+                if (isEof(code)) return endOk(code)
+
+                if (markdownLineEnding(code)) {
+                    effects2.consume(code) // consume EOL to inspect next line head
+                    col = 0
+                    return nextLineHead
+                }
+
+                effects2.consume(code)
+                return restOfLine
+            }
+
+            function nextLineHead(code) {
+                if (isEof(code)) return endOk(code)              // allow EOF
+                if (markdownLineEnding(code)) return endOk(code) // allow blank line
+
+                if (isIndent(code) && col < 512) {
+                    col = advanceColumn(col, code)
+                    effects2.consume(code)
+                    return nextLineHead
+                }
+
+                // next line must start a field: ":" at baseIndent or ddIndent
+                if (code === codes.colon && (col === baseIndentArg || col === ddIndentArg)) {
+                    return endOk(code)
+                }
+
+                // allow an indented, non-blank continuation line for the term
+                if (col > baseIndentArg) return endOk(code)
+
+                return endNok(code)
+            }
+
+            function endOk(code) {
+                if (opened) {
+                    effects2.exit('dlCheck')
+                    opened = false
+                }
+                return ok2(code)
+            }
+
+            function endNok(code) {
+                if (opened) {
+                    effects2.exit('dlCheck')
+                    opened = false
+                }
+                return nok2(code)
+            }
+        }
+    }
+}

package/src/syntax.js

@@ -0,0 +1,31 @@
+import { codes } from 'micromark-util-symbol'
+import { tokenizeDlList } from './tokenize.js'
+
+/**
+ * Micromark extension for colon-based definition lists.
+ *
+ * Syntax (flow):
+ * - A line whose first non-indentation character within 0–3 columns is `:` starts a dl-list.
+ * - The first `:` line is a term (`dt`).
+ * - Subsequent lines indented by 4+ columns and starting with `:` are descriptions (`dd`).
+ * - Continuation lines (indented, without `:`) are appended to the last opened dt/dd.
+ *
+ * Design constraints:
+ * - Do not consume indentation unless dl-list is confirmed by lookahead.
+ * - Do not consume blank-line EOL that terminates the list.
+ *
+ * @returns {import('micromark-util-types').Extension}
+ */
+export function dlList() {
+    /** @type {import('micromark-util-types').Construct} */
+    const construct = { name: 'dlList', tokenize: tokenizeDlList, concrete: true }
+
+    /** @type {import('micromark-util-types').Extension} */
+    return {
+        flow: {
+            [codes.colon]: construct,
+            [codes.space]: construct,
+            [codes.ht]: construct
+        }
+    }
+}

package/src/tokenize.js

@@ -0,0 +1,462 @@
+import { markdownLineEnding } from 'micromark-util-character'
+import { codes } from 'micromark-util-symbol'
+import { MAX_PREFIX_COLS } from './constants.js'
+import {
+    isEof,
+    isIndent,
+    consumeSafe,
+    advanceColumn,
+    consumeLineEndingSafe
+} from './util.js'
+import {
+    checkPrefixFactory,
+    checkAfterEolContinueFactory,
+    checkDlStartFactory
+} from './lookahead.js'
+
+/**
+ * Tokenize a dl-list at flow level.
+ *
+ * @internal
+ * @this {import('micromark-util-types').TokenizeContext}
+ * @param {import('micromark-util-types').Effects} effects
+ * @param {import('micromark-util-types').State} ok
+ * @param {import('micromark-util-types').State} nok
+ * @returns {import('micromark-util-types').State}
+ */
+export function tokenizeDlList(effects, ok, nok) {
+    /** @type {number} */
+    let baseIndent = 0
+
+    /** @type {number} */
+    let ddIndent = 4
+
+    /** @type {'term'|'desc'|null} */
+    let lastField = null
+
+    /** @type {boolean} */
+    let listOpen = false
+    /** @type {boolean} */
+    let itemOpen = false
+    /** @type {boolean} */
+    let termOpen = false
+    /** @type {boolean} */
+    let descOpen = false
+    /** @type {boolean} */
+    let termTextOpen = false
+
+    const closeTermTextIfOpen = () => {
+        if (termTextOpen) {
+            effects.exit('dlTermText')
+            termTextOpen = false
+        }
+    }
+
+    const closeTermIfOpen = () => {
+        closeTermTextIfOpen()
+        if (termOpen) {
+            effects.exit('dlTerm')
+            termOpen = false
+        }
+    }
+
+    const closeDescIfOpen = () => {
+        if (descOpen) {
+            effects.exit('dlDesc')
+            descOpen = false
+        }
+    }
+
+    const closeFieldIfOpen = () => {
+        closeDescIfOpen()
+        closeTermIfOpen()
+        lastField = null
+    }
+
+    const closeItemIfOpen = () => {
+        closeFieldIfOpen()
+        if (itemOpen) {
+            effects.exit('dlItem')
+            itemOpen = false
+        }
+    }
+
+    const closeAll = () => {
+        closeItemIfOpen()
+        if (listOpen) {
+            effects.exit('dlList')
+            listOpen = false
+        }
+    }
+
+    const start = (code) => {
+        baseIndent = 0
+        ddIndent = 4
+        lastField = null
+        listOpen = false
+        itemOpen = false
+        termOpen = false
+        descOpen = false
+        termTextOpen = false
+        return prefix(code, 0)
+    }
+
+    const prefix = (code, col) => {
+        if (isEof(code)) return nok(code)
+
+        if (code === codes.colon) {
+            if (col > 3) return nok(code)
+
+            return effects.check(
+                checkDlStartFactory(col, col + 4),
+                onOk,
+                nok
+            )(code)
+
+            function onOk() {
+                baseIndent = col
+                ddIndent = baseIndent + 4
+                effects.enter('dlList')
+                listOpen = true
+                return termMarker(code)
+            }
+        }
+
+        if (isIndent(code) && col < MAX_PREFIX_COLS) {
+            return effects.check(checkPrefixFactory(), onOk, nok)(code)
+            function onOk() {
+                return prefixConsume(code, 0)
+            }
+        }
+
+        return nok(code)
+    }
+
+    const prefixConsume = (code, col) => {
+        if (isEof(code)) return nok(code)
+
+        if (code === codes.colon) {
+            if (col > 3) return nok(code)
+
+            return effects.check(
+                checkDlStartFactory(col, col + 4),
+                onOk,
+                nok
+            )(code)
+
+            function onOk() {
+                baseIndent = col
+                ddIndent = baseIndent + 4
+                effects.enter('dlList')
+                listOpen = true
+                return termMarker(code)
+            }
+        }
+
+        if (isIndent(code) && col < MAX_PREFIX_COLS) {
+            effects.enter('dlIndent')
+            consumeSafe(effects, code)
+            effects.exit('dlIndent')
+
+            const nextCol = advanceColumn(col, code)
+            if (nextCol > MAX_PREFIX_COLS) return nok(code)
+
+            return (c) => prefixConsume(c, nextCol)
+        }
+
+        return nok(code)
+    }
+
+    const termMarker = (code) => {
+        if (isEof(code) || code !== codes.colon) return nok(code)
+
+        closeItemIfOpen()
+
+        effects.enter('dlItem')
+        itemOpen = true
+
+        effects.enter('dlTerm')
+        termOpen = true
+        lastField = 'term'
+
+        consumeSafe(effects, code) // ':'
+        return afterMarkerToTerm
+    }
+
+    const afterMarkerToTerm = (code) => {
+        if (isEof(code) || markdownLineEnding(code)) return afterEol(code)
+
+        if (isIndent(code)) {
+            effects.enter('dlMarkerSpace')
+            consumeSafe(effects, code)
+            effects.exit('dlMarkerSpace')
+            return termTextStart
+        }
+
+        return termTextStart(code)
+    }
+
+    const termTextStart = (code) => {
+        effects.enter('dlTermText')
+        termTextOpen = true
+        return termText(code)
+    }
+
+    const termText = (code) => {
+        if (isEof(code) || markdownLineEnding(code)) {
+            effects.exit('dlTermText')
+            termTextOpen = false
+            return afterEol(code)
+        }
+        consumeSafe(effects, code)
+        return termText
+    }
+
+    const afterEol = (code) => {
+        if (isEof(code)) {
+            closeAll()
+            return ok(code)
+        }
+        if (!markdownLineEnding(code)) return nok(code)
+
+        // Decide whether to continue *before* claiming the line ending.
+        // If we stop here, leave the line ending to the parent tokenizer.
+        return effects.check(
+            checkAfterEolContinueFactory(),
+            onContinue,
+            onStop
+        )(code)
+
+        function onContinue() {
+            consumeLineEndingSafe(effects, code)
+            return lineStart
+        }
+
+        function onStop() {
+            closeAll()
+            return ok(code)
+        }
+    }
+
+    const lineStart = (code) => {
+        if (isEof(code) || markdownLineEnding(code)) {
+            closeAll()
+            return ok(code)
+        }
+
+        if (code === codes.colon) {
+            closeFieldIfOpen()
+            return termMarker(code)
+        }
+
+        if (isIndent(code)) return scanIndent(code, 0)
+
+        closeAll()
+        return ok(code)
+    }
+
+    const scanIndent = (code, col) => {
+        if (isEof(code)) {
+            closeAll()
+            return ok(code)
+        }
+
+        if (isIndent(code) && col < 512) {
+            effects.enter('dlIndent')
+            consumeSafe(effects, code)
+            effects.exit('dlIndent')
+
+            const nextCol = advanceColumn(col, code)
+            return (c) => scanIndent(c, nextCol)
+        }
+
+        if (col >= ddIndent && code === codes.colon) {
+            closeTermIfOpen()
+            return descMarker(code)
+        }
+
+        if (col === baseIndent && code === codes.colon) {
+            closeFieldIfOpen()
+            return termMarker(code)
+        }
+
+        if (col > baseIndent) {
+            if (!termOpen && !descOpen) {
+                closeAll()
+                return ok(code)
+            }
+            return continuationLine(code)
+        }
+
+        closeAll()
+        return ok(code)
+    }
+
+    const descMarker = (code) => {
+        if (isEof(code) || code !== codes.colon) return nok(code)
+
+        closeDescIfOpen()
+
+        effects.enter('dlDesc')
+        descOpen = true
+        lastField = 'desc'
+
+        consumeSafe(effects, code) // ':'
+        return afterMarkerToDesc
+    }
+
+    const afterMarkerToDesc = (code) => {
+        if (isEof(code)) return afterEol(code)
+
+        // IMPORTANT:
+        // Even if the dd marker line ends immediately, open a container so
+        // subsequent indented lines become part of this dd.
+        // (This removes the need for dlDescText.)
+        if (markdownLineEnding(code)) {
+            const t = effects.enter('dlDescContainer')
+            // @ts-ignore
+            t._dlIndent = ddIndent
+            return descContainerContent(code)
+        }
+
+        // dd マーカー直後のスペースはコンテナに入れない（見た目調整用）
+        if (isIndent(code)) {
+            effects.enter('dlMarkerSpace')
+            consumeSafe(effects, code)
+            effects.exit('dlMarkerSpace')
+            return afterMarkerToDesc
+        }
+
+        const t = effects.enter('dlDescContainer')
+        // html.js が参照する deindent 量（columns）
+        // @ts-ignore
+        t._dlIndent = ddIndent
+
+        return descContainerContent(code)
+    }
+
+    const descContainerContent = (code) => {
+        if (isEof(code)) {
+            effects.exit('dlDescContainer')
+            closeAll()
+            return ok(code)
+        }
+
+        if (markdownLineEnding(code)) {
+            return effects.check(
+                checkAfterEolContinueFactory(),
+                onContinue,
+                onStop
+            )(code)
+
+            function onContinue() {
+                consumeLineEndingSafe(effects, code)
+                return descContainerLineStart
+            }
+
+            function onStop() {
+                effects.exit('dlDescContainer')
+                closeAll()
+                return ok(code)
+            }
+        }
+
+        consumeSafe(effects, code)
+        return descContainerContent
+    }
+
+    const descContainerLineStart = (code) => {
+        if (isEof(code)) {
+            effects.exit('dlDescContainer')
+            closeAll()
+            return ok(code)
+        }
+
+        if (markdownLineEnding(code)) {
+            // 空行はコンテナに含める（段落分離に必要）
+            consumeLineEndingSafe(effects, code)
+            return descContainerLineStart
+        }
+
+        // 次行が ":" で始まる (= 次の term / 同階層) 場合、dd コンテナを閉じて tokenizer 側で処理
+        if (code === codes.colon) {
+            effects.exit('dlDescContainer')
+            closeDescIfOpen()
+            return lineStart(code)
+        }
+
+        if (isIndent(code)) return descContainerScanIndent(code, 0)
+
+        // インデント無しは dl-list 終了
+        effects.exit('dlDescContainer')
+        closeAll()
+        return ok(code)
+    }
+
+    const descContainerScanIndent = (code, col) => {
+        if (isEof(code)) {
+            effects.exit('dlDescContainer')
+            closeAll()
+            return ok(code)
+        }
+
+        if (isIndent(code) && col < 512) {
+            // コンテナなので indent もそのまま入れる
+            consumeSafe(effects, code)
+            const nextCol = advanceColumn(col, code)
+            return (c) => descContainerScanIndent(c, nextCol)
+        }
+
+        if (col === baseIndent && code === codes.colon) {
+            effects.exit('dlDescContainer')
+            closeDescIfOpen()
+            return termMarker(code)
+        }
+
+        // 深いインデントの ":" は dd 本文（入れ子 dl 等）の可能性があるので閉じない
+        if (col === ddIndent && code === codes.colon) {
+            effects.exit('dlDescContainer')
+            closeDescIfOpen()
+            return descMarker(code)
+        }
+
+        // それ以外は dd 本文継続（この行の残りを食う）
+        return descContainerContent(code)
+    }
+
+    const continuationLine = (code) => {
+        effects.enter('dlHardBreak')
+        effects.exit('dlHardBreak')
+
+        if (lastField === 'term' && termOpen) {
+            effects.enter('dlTermText')
+            termTextOpen = true
+            return contTextAsTerm(code)
+        }
+
+        if (lastField === 'desc' && descOpen) {
+            // Fallback safety:
+            // If we ever reach here with an open dd but no container,
+            // treat continuation as dd container content (no dlDescText).
+            const t = effects.enter('dlDescContainer')
+            // @ts-ignore
+            t._dlIndent = ddIndent
+            return descContainerContent(code)
+        }
+
+        closeAll()
+        return ok(code)
+    }
+
+    const contTextAsTerm = (code) => {
+        if (isEof(code) || markdownLineEnding(code)) {
+            effects.exit('dlTermText')
+            termTextOpen = false
+            return afterEol(code)
+        }
+        consumeSafe(effects, code)
+        return contTextAsTerm
+    }
+
+    return start
+}

package/src/util.js

@@ -0,0 +1,72 @@
+import { markdownLineEnding } from 'micromark-util-character'
+import { codes } from 'micromark-util-symbol'
+import { TAB_SIZE } from './constants.js'
+
+/**
+ * @param {number|null} code
+ * @returns {boolean}
+ */
+export function isEof(code) {
+    return code === codes.eof
+}
+
+/**
+ * True for indentation codes that micromark uses at line starts.
+ *
+ * @param {number|null} code
+ * @returns {boolean}
+ */
+export function isIndent(code) {
+    return (
+        code === codes.space ||
+        code === codes.ht ||
+        code === codes.virtualSpace ||
+        code === codes.horizontalTab
+    )
+}
+
+/**
+ * Consume a code only when it represents a number.
+ * (micromark uses negative “virtual” codes too; those are still numbers and are valid to consume.)
+ *
+ * @param {import('micromark-util-types').Effects} effects
+ * @param {number|null} code
+ * @returns {void}
+ */
+export function consumeSafe(effects, code) {
+    if (typeof code !== 'number') return
+    effects.consume(code)
+}
+
+/**
+ * Advance column count by one character, respecting TAB_SIZE.
+ *
+ * @param {number} col
+ * @param {number|null} code
+ * @returns {number}
+ */
+export function advanceColumn(col, code) {
+    if (code === codes.ht || code === codes.horizontalTab) {
+        const r = col % TAB_SIZE
+        return col + (r === 0 ? TAB_SIZE : TAB_SIZE - r)
+    }
+    return col + 1
+}
+
+/**
+ * Consume a line ending as a token (`dlLineEnding`) so downstream can reason about it.
+ *
+ * NOTE:
+ * - Do not call this in the "blank line ends dl-list" path.
+ *   In that case, the EOL must remain for CommonMark to see the blank-line boundary.
+ *
+ * @param {import('micromark-util-types').Effects} effects
+ * @param {number|null} code
+ * @returns {void}
+ */
+export function consumeLineEndingSafe(effects, code) {
+    if (!markdownLineEnding(code)) return
+    effects.enter('dlLineEnding')
+    effects.consume(code)
+    effects.exit('dlLineEnding')
+}