comark 0.3.2 → 0.5.0

package/dist/internal/parse/token-processor.js

@@ -1,4 +1,6 @@
 import { htmlToComarkNodes, parseInlineHtmlTag } from "./html/index.js";
+// `::tag` components that should fold into a single same-tagged child.
+const WRAPPER_TAGS = new Set(['ul', 'ol', 'table', 'blockquote', 'pre']);
 // Mapping from token types to tag names
 const BLOCK_TAG_MAP = {
     blockquote_open: 'blockquote',
@@ -17,7 +19,8 @@ const INLINE_TAG_MAP = {
     strong_open: 'strong',
     em_open: 'em',
     s_open: 'del',
-    sub_open: 'del',
+    sub_open: 'sub',
+    sup_open: 'sup',
 };
 // ─── main entry point ───────────────────────────────────────────────────────
 /**
@@ -33,6 +36,13 @@ export function marmdownItTokensToComarkTree(tokens, options = { startLine: 0, p
     let i = 0;
     let endLine = options.startLine;
     while (i < tokens.length) {
+        const token = tokens[i];
+        if (token.type === 'html_block') {
+            const result = processHtmlBlockTokens(tokens, i);
+            nodes.push(...result.nodes);
+            i = result.nextIndex;
+            continue;
+        }
         const result = processBlockToken(tokens, i, false, state);
         if (result.node) {
             if (options.preservePositions) {
@@ -54,6 +64,15 @@ export function marmdownItTokensToComarkTree(tokens, options = { startLine: 0, p
     }
     return nodes;
 }
+/**
+ * Convert an html_block token into Comark nodes. The whole HTML payload is
+ * parsed once by htmlparser2; text inside is preserved verbatim (no markdown
+ * re-parsing — CommonMark default).
+ */
+function processHtmlBlockTokens(tokens, startIndex) {
+    const content = typeof tokens[startIndex]?.content === 'string' ? tokens[startIndex].content : '';
+    return { nodes: htmlToComarkNodes(content), nextIndex: startIndex + 1 };
+}
 /**
  * Extract and process attributes from a token's attrs array
  */
@@ -72,11 +91,7 @@ function processAttributes(attrsArray, options = {}) {
                 continue;
             }
             // Handle boolean attributes: {bool} -> {":bool": "true"}
-            if (handleBoolean &&
-                !key.startsWith(':') &&
-                !key.startsWith('#') &&
-                !key.startsWith('.') &&
-                (!value || value === 'true' || value === '')) {
+            if (handleBoolean && !key.startsWith(':') && !key.startsWith('#') && !key.startsWith('.') && value === 'true') {
                 attrs[`:${key}`] = 'true';
                 continue;
             }
@@ -222,22 +237,12 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
     if (token.type === 'hr') {
         return { node: ['hr', {}], nextIndex: startIndex + 1 };
     }
-    // html_block is now handled upstream (in marmdownItTokensToComarkTree /
+    // html_block is normally handled upstream (in marmdownItTokensToComarkTree /
     // processBlockChildren / processBlockChildrenWithSlots) before reaching here.
-    // This branch is kept as a safety fallback.
+    // Safety fallback when it slips through.
     if (token.type === 'html_block') {
-        const content = token.content?.trim() || '';
-        if (content.startsWith('<!--')) {
-            const inner = content.endsWith('-->') ? content.slice(4, -3) : content.slice(4);
-            return { node: [null, {}, inner], nextIndex: startIndex + 1 };
-        }
-        const children = processBlockChildren(tokens, startIndex + 1, 'html_block_close', false, false, false, state);
-        const [node1] = htmlToComarkNodes(content);
-        if (!node1) {
-            return { node: null, nextIndex: startIndex + 1 };
-        }
-        const node = [node1[0], node1[1], ...children.nodes];
-        return { node, nextIndex: children.nextIndex + 1 };
+        const result = processHtmlBlockTokens(tokens, startIndex);
+        return { node: result.nodes[0] ?? null, nextIndex: result.nextIndex };
     }
     // Handle Comark block components (e.g., ::component ... ::)
     if (token.type === 'mdc_block_open') {
@@ -245,6 +250,20 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
         const attrs = processAttributes(token.attrs);
         // Process children until mdc_block_close, handling slots (#slotname)
         const children = processBlockChildrenWithSlots(tokens, startIndex + 1, 'mdc_block_close', state);
+        // `::ul`/`::ol`/`::table`/`::blockquote`/`::pre` wrapping a single same-tag
+        // child collapses into a single element with the wrapper's attrs (outer wins).
+        if (WRAPPER_TAGS.has(componentName) &&
+            children.nodes.length === 1 &&
+            Array.isArray(children.nodes[0]) &&
+            children.nodes[0][0] === componentName) {
+            const inner = children.nodes[0];
+            const innerAttrs = inner[1];
+            const innerChildren = inner.slice(2);
+            return {
+                node: [componentName, { ...innerAttrs, ...attrs }, ...innerChildren],
+                nextIndex: children.nextIndex + 1,
+            };
+        }
         // Return the component even if it has no children (empty component like ::component\n::)
         return { node: [componentName, attrs, ...children.nodes], nextIndex: children.nextIndex + 1 };
     }
@@ -311,15 +330,17 @@ function processBlockToken(tokens, startIndex, insideNestedContext = false, stat
     if (token.type === 'heading_open') {
         const level = Number.parseInt(token.tag.replace('h', ''), 10);
         const headingTag = `h${level}`;
+        const userAttrs = processAttributes(token.attrs, { handleBoolean: false, handleJSON: false });
         // Process heading children with inHeading flag for Comark component handling
         const children = processBlockChildren(tokens, startIndex + 1, 'heading_close', true, true, insideNestedContext, state);
         if (children.nodes.length > 0) {
             // Always generate ID for all headings, no exceptions
             const textContent = extractTextContent(children.nodes);
             const headingId = uniqueSlug(slugify(textContent), level, state);
-            // Always attach ID to the heading element itself
+            // Merge user-supplied attrs with the auto-generated id; user `id` wins.
+            const attrs = { id: headingId, ...userAttrs };
             return {
-                node: [headingTag, { id: headingId }, ...children.nodes],
+                node: [headingTag, attrs, ...children.nodes],
                 nextIndex: children.nextIndex + 1,
             };
         }
@@ -351,25 +372,26 @@ function processBlockChildrenWithSlots(tokens, startIndex, closeType, state) {
     const nodes = [];
     let i = startIndex;
     let currentSlotName = null;
+    let currentSlotAttrs = {};
     let currentSlotChildren = [];
     while (i < tokens.length && tokens[i].type !== closeType) {
         const token = tokens[i];
         // html_block can produce multiple nodes — handle before processBlockToken
         if (token.type === 'html_block') {
-            const htmlNodes = htmlToComarkNodes(token.content);
+            const result = processHtmlBlockTokens(tokens, i);
             if (currentSlotName !== null) {
-                currentSlotChildren.push(...htmlNodes);
+                currentSlotChildren.push(...result.nodes);
             }
             else {
-                nodes.push(...htmlNodes);
+                nodes.push(...result.nodes);
             }
-            i++;
+            i = result.nextIndex;
             continue;
         }
         // Check for slot marker: #slotname creates mdc_block_slot tokens
         if (token.type === 'mdc_block_slot') {
             // Extract slot name from token.attrs
-            // The attrs array contains [["#slotname", ""]] for open, and null/empty for close
+            // The attrs array contains [["#slotname", ""], ...props] for open, and null/empty for close
             if (token.attrs && Array.isArray(token.attrs) && token.attrs.length > 0) {
                 const firstAttr = token.attrs[0];
                 if (Array.isArray(firstAttr) && firstAttr.length > 0) {
@@ -377,12 +399,21 @@ function processBlockChildrenWithSlots(tokens, startIndex, closeType, state) {
                     // Remove the # prefix to get the slot name
                     if (slotKey.startsWith('#')) {
                         const slotName = slotKey.substring(1);
+                        const slotAttrs = processAttributes(token.attrs.slice(1));
                         // Save previous slot if any
                         if (currentSlotName !== null && currentSlotChildren.length > 0) {
-                            nodes.push(['template', { name: currentSlotName }, ...currentSlotChildren]);
+                            nodes.push([
+                                'template',
+                                {
+                                    name: currentSlotName,
+                                    ...currentSlotAttrs,
+                                },
+                                ...currentSlotChildren,
+                            ]);
                             currentSlotChildren = [];
                         }
                         currentSlotName = slotName;
+                        currentSlotAttrs = slotAttrs;
                         i++;
                         continue;
                     }
@@ -409,7 +440,14 @@ function processBlockChildrenWithSlots(tokens, startIndex, closeType, state) {
     }
     // Save last slot if any
     if (currentSlotName !== null && currentSlotChildren.length > 0) {
-        nodes.push(['template', { name: currentSlotName }, ...currentSlotChildren]);
+        nodes.push([
+            'template',
+            {
+                name: currentSlotName,
+                ...currentSlotAttrs,
+            },
+            ...currentSlotChildren,
+        ]);
     }
     return { nodes, nextIndex: i };
 }
@@ -418,10 +456,10 @@ function processBlockChildren(tokens, startIndex, closeType, inlineOnly, inHeadi
     let i = startIndex;
     while (i < tokens.length && tokens[i].type !== closeType) {
         const token = tokens[i];
-        // html_block can produce multiple nodes — handle before processBlockToken
         if (token.type === 'html_block') {
-            nodes.push(...htmlToComarkNodes(token.content));
-            i++;
+            const result = processHtmlBlockTokens(tokens, i);
+            nodes.push(...result.nodes);
+            i = result.nextIndex;
             continue;
         }
         if (token.type === 'inline') {

package/dist/internal/stringify/attributes.d.ts

@@ -5,7 +5,7 @@ export interface ResolveAttributesOptions {
      * `:` prefix is always stripped. Non-JSON strings fall back to a dot-path
      * lookup in `renderData`; unresolved paths yield `undefined`.
      *
-     * This matches the Vue/React/Svelte renderer semantics, which always
+     * This matches the Vue/React/Svelte/Angular renderer semantics, which always
      * normalize bindings into real JS values suitable for typed component props.
      *
      * When false (default) only dot-path lookups are applied — literals and
@@ -34,6 +34,13 @@ export declare function resolveAttributes(attrs: Record<string, unknown>, render
  * binding doesn't resolve.
  */
 export declare function resolveAttribute(attrs: Record<string, unknown>, renderData: NodeRenderData, key: string): unknown;
+/**
+ * Filter implicit/auto-generated attrs that are encoded by the native
+ * markdown syntax and shouldn't echo back as `{attr=...}`. Used by the
+ * block stringifiers to decide whether a node has *user* attrs that must
+ * be preserved via the `::tag{...}` wrapper form.
+ */
+export declare function userBlockAttrs(tag: string, attributes: Record<string, unknown>): Record<string, unknown>;
 /**
  * Convert attributes to a string of Comark attributes
  *

package/dist/internal/stringify/attributes.js

@@ -67,6 +67,59 @@ export function resolveAttribute(attrs, renderData, key) {
     }
     return attrs[key];
 }
+// Implicit attributes the parser injects per tag — they're conveyed by the
+// native markdown syntax (e.g. `as` becomes `> [!NOTE]`, `task-list-item`
+// is implicit in `- [ ]`) so they should not echo back as user attrs.
+const IMPLICIT_ATTRS = {
+    blockquote: { drop: ['as'] },
+    ol: { drop: ['start'] },
+    ul: { classBlocklist: ['contains-task-list'] },
+    li: { classBlocklist: ['task-list-item'] },
+    // `language`/`filename`/`highlights`/`meta` ride on the fence info string.
+    // `style` comes from render-time plugins (e.g. shiki) and has no markdown
+    // form. `class` is handled specially in userBlockAttrs because shiki merges
+    // its injected classes with the user's class — we need to strip just the
+    // highlighter portion.
+    pre: { drop: ['language', 'filename', 'highlights', 'meta', 'style'] },
+};
+/**
+ * Filter implicit/auto-generated attrs that are encoded by the native
+ * markdown syntax and shouldn't echo back as `{attr=...}`. Used by the
+ * block stringifiers to decide whether a node has *user* attrs that must
+ * be preserved via the `::tag{...}` wrapper form.
+ */
+export function userBlockAttrs(tag, attributes) {
+    const rule = IMPLICIT_ATTRS[tag];
+    if (!rule)
+        return { ...attributes };
+    const result = {};
+    for (const [key, value] of Object.entries(attributes)) {
+        if (rule.drop?.includes(key))
+            continue;
+        if (key === 'class' && rule.classBlocklist && typeof value === 'string') {
+            const remaining = value
+                .split(/\s+/)
+                .filter((c) => c && !rule.classBlocklist.includes(c))
+                .join(' ');
+            if (remaining)
+                result[key] = remaining;
+            continue;
+        }
+        if (key === 'class' && tag === 'pre' && typeof value === 'string' && value.startsWith('shiki')) {
+            // Shiki injects `shiki [shiki-themes] <themes…>` (or a bare `shiki`) and
+            // appends any user class after a `.` separator. Recover the user portion
+            // by dropping everything up to and including that separator.
+            const tokens = value.split(/\s+/);
+            let cutoff = tokens.findIndex((t) => t === '.');
+            const userClass = cutoff >= 0 ? tokens.slice(cutoff + 1).join(' ') : '';
+            if (userClass)
+                result[key] = userClass;
+            continue;
+        }
+        result[key] = value;
+    }
+    return result;
+}
 /**
  * Convert attributes to a string of Comark attributes
  *

package/dist/internal/stringify/handlers/blockquote.js

@@ -1,9 +1,26 @@
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 export async function blockquote(node, state) {
     const children = node.slice(2);
     let childResult = '';
     for (const child of children) {
         childResult += await state.one(child, state, node);
     }
+    const userAttrs = userBlockAttrs('blockquote', node[1]);
+    const attrs = comarkAttributes(userAttrs);
+    const hasBlockChildren = children.some((c) => Array.isArray(c));
+    // Multi-block content with attrs has no unambiguous inline form — round-trip
+    // via `::blockquote{attrs}` so the attrs aren't visually attached to one
+    // paragraph and parsers can recover the same AST.
+    if (attrs && hasBlockChildren) {
+        const content = childResult
+            .trim()
+            .split('\n')
+            .map((line) => (line ? `> ${line}` : '>'))
+            .join('\n');
+        return `::blockquote${attrs}\n${content}\n::` + state.context.blockSeparator;
+    }
+    if (attrs)
+        childResult = `${childResult.replace(/[ \t]+$/, '')} ${attrs}`;
     const content = childResult
         .trim()
         .split('\n')

package/dist/internal/stringify/handlers/heading.js

@@ -1,7 +1,12 @@
+import { comarkAttributes } from "../attributes.js";
 // h1, h2, h3, h4, h5, h6
 export async function heading(node, state) {
     const [tag] = node;
     const level = Number(tag.slice(1));
     const content = await state.flow(node, state);
-    return '#'.repeat(level) + ' ' + content + state.context.blockSeparator;
+    // The auto-generated id is implicit in `# Heading` markdown — don't echo it.
+    const { id: _id, ...rest } = node[1];
+    const attrs = comarkAttributes(rest);
+    const suffix = attrs ? ` ${attrs}` : '';
+    return '#'.repeat(level) + ' ' + content + suffix + state.context.blockSeparator;
 }

package/dist/internal/stringify/handlers/html.js

@@ -82,12 +82,18 @@ export async function html(node, state, parent) {
         return `<${tag}${attrs} />` + (!parent && !isInline ? state.context.blockSeparator : '');
     }
     if (!oneLiner && content) {
-        content = '\n' + paddNoneHtmlContent(content, state).trimEnd() + '\n';
+        content = '\n' + paddNoneHtmlContent(content, state, String(tag)).trimEnd() + '\n';
     }
     return `<${tag}${attrs}>${content}</${tag}>` + (!parent && !isInline ? state.context.blockSeparator : '');
 }
-function paddNoneHtmlContent(content, state) {
+// Literal-content tags whose body must be rendered verbatim (no indentation
+// re-flow). Matches the parser-side set so `<style>` / `<script>` etc. stay
+// flush-left in the output, the way they were authored.
+const LITERAL_CONTENT_TAGS = new Set(['code', 'kbd', 'pre', 'samp', 'script', 'style', 'textarea', 'var']);
+function paddNoneHtmlContent(content, state, tag) {
     if (state.context.html) {
+        if (LITERAL_CONTENT_TAGS.has(tag.toLowerCase()))
+            return content;
         return indent(content);
     }
     return (content.trim().startsWith('<') ? '' : '') + content + (content.trim().endsWith('>') ? '' : '');

package/dist/internal/stringify/handlers/li.js

@@ -1,4 +1,5 @@
 import { indent } from "../../../utils/index.js";
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 // Block elements that need explicit indentation in list items.
 // Note: ol/ul are handled by their own handlers which manage indentation via listIndent context.
 const blockElements = new Set(['pre', 'blockquote', 'table']);
@@ -15,32 +16,41 @@ export async function li(node, state) {
         prefix += input[1].checked || input[1][':checked'] ? '[x] ' : '[ ] ';
     }
     const prefixWidth = prefix.length;
+    // Direct text children render sibling components inline.
+    const hasInlineContent = children.some((child) => typeof child === 'string');
     let result = '';
     for (const child of children) {
-        const rendered = await state.one(child, state, node);
-        if (result && Array.isArray(child)) {
-            if (blockElements.has(child[0])) {
-                // Block-level child: put on its own line and indent to align with list prefix
-                const indented = indent(rendered, { width: prefixWidth });
+        if (Array.isArray(child)) {
+            const tag = child[0];
+            if (result && blockElements.has(tag)) {
+                const indented = indent(await state.one(child, state, node), { width: prefixWidth });
                 result = result.trimEnd() + '\n' + indented.trimEnd() + '\n';
                 continue;
             }
-            if (child[0] === 'p') {
-                const indented = indent(rendered, { width: prefixWidth });
+            if (result && tag === 'p') {
+                const indented = indent(await state.one(child, state, node), { width: prefixWidth });
                 result = result.trimEnd() + '\n\n' + indented.trimEnd() + '\n';
                 continue;
             }
+            // No parent → mdc skips its own nesting indentation, so li owns it here.
+            if (!hasInlineContent && !(tag in state.handlers)) {
+                const indented = indent(await state.one(child, state), { width: prefixWidth, ignoreFirstLine: !result });
+                result = result ? result.trimEnd() + '\n' + indented.trimEnd() + '\n' : indented.trimEnd() + '\n';
+                continue;
+            }
         }
-        result += rendered;
+        result += await state.one(child, state, node);
     }
     result = result.trim();
+    const attrs = comarkAttributes(userBlockAttrs('li', node[1]));
+    const suffix = attrs ? ` ${attrs}` : '';
     if (!order) {
         result = escapeLeadingNumberDot(result);
     }
     if (order) {
         state.applyContext({ order: order + 1 });
     }
-    return `${prefix}${result}\n`;
+    return `${prefix}${result}${suffix}\n`;
 }
 function escapeLeadingNumberDot(str) {
     if (str.length === 0)

package/dist/internal/stringify/handlers/mdc.js

@@ -5,7 +5,7 @@ import { html } from "./html.js";
 const INLINE_HTML_ELEMENTS = new Set(['a', 'strong', 'em', 'span']);
 export async function mdc(node, state, parent) {
     const [tag, attr, ...children] = node;
-    const { $, ...attributes } = attr;
+    const { $: _, ...attributes } = attr;
     if (tag === 'table') {
         return html(node, state);
     }

package/dist/internal/stringify/handlers/ol.js

@@ -1,18 +1,31 @@
 import { indent } from "../../../utils/index.js";
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 export async function ol(node, state) {
     const children = node.slice(2);
-    const revert = state.applyContext({ list: true, order: 1, listIndent: 3 });
+    // `start` is carried by the native numbering; IMPLICIT_ATTRS drops it from user attrs.
+    const start = Number(node[1].start);
+    const order = Number.isInteger(start) && start >= 1 ? start : 1;
+    const revert = state.applyContext({ list: true, order, listIndent: 3 });
     let result = '';
     for (const child of children) {
         result += await state.one(child, state);
     }
     result = result.trim();
+    state.applyContext(revert);
+    // ol with user attrs round-trips via `::ol{attrs}\n1. …\n::` — the native
+    // markdown list syntax has no slot for list-level attrs.
+    const attrs = comarkAttributes(userBlockAttrs('ol', node[1]));
+    if (attrs) {
+        if (revert.list) {
+            return '\n' + indent(`::ol${attrs}\n${result}\n::`, { width: revert.listIndent || 2 });
+        }
+        return `::ol${attrs}\n${result}\n::` + state.context.blockSeparator;
+    }
     if (revert.list) {
         result = '\n' + indent(result, { width: revert.listIndent || 2 });
     }
     else {
         result = result + state.context.blockSeparator;
     }
-    state.applyContext(revert);
     return result;
 }

package/dist/internal/stringify/handlers/p.js

@@ -1,9 +1,13 @@
+import { comarkAttributes } from "../attributes.js";
 export async function p(node, state, parent) {
     const children = node.slice(2);
     let result = '';
     for (const child of children) {
         result += await state.one(child, state, node);
     }
+    const attrs = comarkAttributes(node[1]);
+    if (attrs)
+        result = `${result.replace(/[ \t]+$/, '')} ${attrs}`;
     if (parent?.[0] === 'li') {
         return result;
     }

package/dist/internal/stringify/handlers/pre.js

@@ -1,4 +1,5 @@
 import { textContent } from "../../../utils/index.js";
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 export function pre(node, state) {
     const [_, attributes, ...children] = node;
     const codeClasses = children[0]?.[1]?.class;
@@ -13,8 +14,16 @@ export function pre(node, state) {
     const highlights = attributes.highlights ? ' {' + formatHighlights(attributes.highlights) + '}' : '';
     // Meta always has a leading space
     const meta = attributes.meta ? ' ' + attributes.meta : '';
-    const result = '```' + language + filename + highlights + meta + '\n' + String(node[1]?.code || textContent(node)).trim() + '\n```';
-    return result + state.context.blockSeparator;
+    const code = String(node[1]?.code || textContent(node)).trim();
+    const fence = code.includes('```') ? '~~~' : '```';
+    const fenceBlock = fence + language + filename + highlights + meta + '\n' + code + '\n' + fence;
+    // Extra user attrs that can't ride on the fence info string round-trip via
+    // `::pre{attrs}\n```…```\n::` — mirrors the wrapper form for ul/ol/table/blockquote.
+    const attrs = comarkAttributes(userBlockAttrs('pre', attributes));
+    if (attrs) {
+        return `::pre${attrs}\n${fenceBlock}\n::` + state.context.blockSeparator;
+    }
+    return fenceBlock + state.context.blockSeparator;
 }
 function formatHighlights(highlights) {
     if (highlights.length === 0)

package/dist/internal/stringify/handlers/table.js

@@ -1,3 +1,4 @@
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 // Helper function to extract alignment from style attribute
 function getAlignment(attributes) {
     const style = attributes.style;
@@ -158,6 +159,12 @@ export async function table(node, state) {
         result += '| ' + cellContents.join(' | ') + ' |\n';
     }
     // result already ends with \n, so we only need to add one more \n
+    // table with user attrs round-trips via `::table{attrs}\n<table>\n::` —
+    // GFM table syntax has no slot for table-level attrs.
+    const attrs = comarkAttributes(userBlockAttrs('table', node[1]));
+    if (attrs) {
+        return `::table${attrs}\n${result.trimEnd()}\n::\n\n`;
+    }
     return result + '\n';
 }
 export function thead(_node, _state) {

package/dist/internal/stringify/handlers/template.js

@@ -1,3 +1,4 @@
+import { comarkAttributes } from "../attributes.js";
 // slot template
 export async function template(node, state, parent) {
     const [_, attrs] = node;
@@ -10,5 +11,7 @@ export async function template(node, state, parent) {
             return content + state.context.blockSeparator;
         }
     }
-    return `#${attrs.name}\n${content}` + state.context.blockSeparator;
+    const { name: _name, $: _$, ...rest } = attrs;
+    const extraAttrs = comarkAttributes(rest);
+    return `#${attrs.name}${extraAttrs}\n${content}` + state.context.blockSeparator;
 }

package/dist/internal/stringify/handlers/ul.js

@@ -1,4 +1,5 @@
 import { indent } from "../../../utils/index.js";
+import { comarkAttributes, userBlockAttrs } from "../attributes.js";
 export async function ul(node, state) {
     const children = node.slice(2);
     const revert = state.applyContext({ list: true, order: false, listIndent: 2 });
@@ -7,12 +8,21 @@ export async function ul(node, state) {
         result += await state.one(child, state);
     }
     result = result.trim();
+    state.applyContext(revert);
+    // ul with user attrs round-trips via `::ul{attrs}\n- …\n::` — the native
+    // markdown list syntax has no slot for list-level attrs.
+    const attrs = comarkAttributes(userBlockAttrs('ul', node[1]));
+    if (attrs) {
+        if (revert.list) {
+            return '\n' + indent(`::ul${attrs}\n${result}\n::`, { width: revert.listIndent || 2 });
+        }
+        return `::ul${attrs}\n${result}\n::` + state.context.blockSeparator;
+    }
     if (revert.list) {
         result = '\n' + indent(result, { width: revert.listIndent || 2 });
     }
     else {
         result = result + state.context.blockSeparator;
     }
-    state.applyContext(revert);
     return result;
 }

package/dist/internal/stringify/state.js

@@ -25,7 +25,7 @@ export async function one(node, state, parent) {
         if (state.context.html) {
             return escapeHtml(node);
         }
-        return node;
+        return escapeMarkdownText(node);
     }
     if (node[0] === null) {
         return await state.handlers.comment(node, state);
@@ -175,3 +175,15 @@ function escapeHtml(text) {
     };
     return text.replace(/[<>]/g, (char) => map[char]);
 }
+/**
+ * Escape characters in a markdown text node that would otherwise be
+ * misinterpreted as markdown syntax on a subsequent parse.
+ *
+ * `[` opens link/image syntax; `]` closes it.  Both must be escaped so that
+ * a text node like `[foo](bar)` round-trips as plain text, and a text node
+ * containing `]` inside a link (e.g. `dsd]dsd`) doesn't prematurely close
+ * the surrounding `[…]` brackets.
+ */
+function escapeMarkdownText(text) {
+    return text.replace(/[[\]]/g, (ch) => `\\${ch}`);
+}

package/dist/parse.d.ts

@@ -1,4 +1,4 @@
-import type { ComarkParseFn, ParseOptions, ComarkTree } from './types.ts';
+import type { ComarkParseFn, ComarkPlugin, MergePluginFrontmatter, MergePluginMeta, ParseOptions, ResolvedFrontmatter, ResolvedMeta, ComarkTree } from './types.ts';
 export { parseFrontmatter } from './internal/frontmatter.ts';
 export { defineComarkPlugin } from './utils/helpers.ts';
 /**
@@ -30,7 +30,7 @@ export { defineComarkPlugin } from './utils/helpers.ts';
  * const parseNoHtml = createParse({ html: false })
  * ```
  */
-export declare function createParse(options?: ParseOptions): ComarkParseFn;
+export declare function createParse<const TPlugins extends readonly ComarkPlugin<any, any>[] = []>(options?: ParseOptions<TPlugins>): ComarkParseFn<ResolvedMeta<MergePluginMeta<TPlugins>>, ResolvedFrontmatter<MergePluginFrontmatter<TPlugins>>>;
 /**
  * Parse Comark content from a string
  *
@@ -64,7 +64,7 @@ export declare function createParse(options?: ParseOptions): ComarkParseFn;
  * const tree2 = await parse(content, { autoUnwrap: false })
  * ```
  */
-export declare function parse(markdown: string, options?: ParseOptions): Promise<ComarkTree>;
+export declare function parse<const TPlugins extends readonly ComarkPlugin<any, any>[] = []>(markdown: string, options?: ParseOptions<TPlugins>): Promise<ComarkTree<ResolvedMeta<MergePluginMeta<TPlugins>>, ResolvedFrontmatter<MergePluginFrontmatter<TPlugins>>>>;
 /**
  * Creates a serialized parser function for Comark content.
  * This is useful for parsing large files in a streaming manner.
@@ -80,4 +80,4 @@ export declare function parse(markdown: string, options?: ParseOptions): Promise
  * const tree = await parse(content)
  * console.log(tree.nodes)
  */
-export declare function createSerializedParse(options?: ParseOptions): ComarkParseFn;
+export declare function createSerializedParse<const TPlugins extends readonly ComarkPlugin<any, any>[] = []>(options?: ParseOptions<TPlugins>): ComarkParseFn<ResolvedMeta<MergePluginMeta<TPlugins>>, ResolvedFrontmatter<MergePluginFrontmatter<TPlugins>>>;