comark 0.3.1 → 0.3.2

package/dist/internal/stringify/attributes.js

@@ -83,7 +83,10 @@ export function comarkAttributes(attributes) {
             return `#${value}`;
         }
         if (key === 'class') {
-            return value.split(' ').map(c => `.${c}`).join('');
+            return value
+                .split(' ')
+                .map((c) => `.${c}`)
+                .join('');
         }
         if (typeof value === 'object') {
             return `${key}="${JSON.stringify(value).replace(/"/g, '\\"')}"`;

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

@@ -3,9 +3,7 @@ import { comarkAttributes } from "../attributes.js";
 export async function a(node, state) {
     const [_, attrs] = node;
     const { href, ...rest } = attrs;
-    const attrsString = Object.keys(rest).length > 0
-        ? comarkAttributes(rest)
-        : '';
+    const attrsString = Object.keys(rest).length > 0 ? comarkAttributes(rest) : '';
     const content = await state.flow(node, state);
     if (content === href && !attrsString) {
         return `<${href}>`;

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

@@ -7,12 +7,10 @@ export async function blockquote(node, state) {
     const content = childResult
         .trim()
         .split('\n')
-        .map(line => line ? `> ${line}` : '>')
+        .map((line) => (line ? `> ${line}` : '>'))
         .join('\n');
     if (node[1].as) {
-        return `> [!${String(node[1].as).toUpperCase()}]\n`
-            + content
-            + state.context.blockSeparator;
+        return `> [!${String(node[1].as).toUpperCase()}]\n` + content + state.context.blockSeparator;
     }
     return content + state.context.blockSeparator;
 }

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

@@ -2,9 +2,7 @@ import { comarkAttributes } from "../attributes.js";
 import { textContent } from "../../../utils/index.js";
 export function code(node, _state) {
     const [_, attrs] = node;
-    const attrsString = Object.keys(attrs).length > 0
-        ? comarkAttributes(attrs)
-        : '';
+    const attrsString = Object.keys(attrs).length > 0 ? comarkAttributes(attrs) : '';
     const content = textContent(node);
     const fence = content.includes('`') ? '``' : '`';
     return `${fence}${content}${fence}${attrsString}`;

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

@@ -6,8 +6,6 @@ export async function emphesis(node, state) {
         content += await state.one(child, state, node);
     }
     content = content.trim();
-    const attrsString = Object.keys(attrs).length > 0
-        ? comarkAttributes(attrs)
-        : '';
+    const attrsString = Object.keys(attrs).length > 0 ? comarkAttributes(attrs) : '';
     return `*${content}*${attrsString}`;
 }

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

@@ -1,9 +1,25 @@
 import { htmlAttributes } from "../attributes.js";
-import { indent } from "../indent.js";
+import { indent } from "../../../utils/index.js";
 const textBlocks = new Set(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'td', 'th']);
 const selfCloseTags = new Set(['br', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr']);
 const inlineTags = new Set(['strong', 'em', 'code', 'a', 'br', 'span', 'img']);
-const blockTags = new Set(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'ul', 'ol', 'blockquote', 'hr', 'table', 'td', 'th']);
+const blockTags = new Set([
+    'p',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'li',
+    'ul',
+    'ol',
+    'blockquote',
+    'hr',
+    'table',
+    'td',
+    'th',
+]);
 export async function html(node, state, parent) {
     const [tag, attr, ...children] = node;
     const { $ = {}, ...rawAttributes } = attr;
@@ -15,11 +31,9 @@ export async function html(node, state, parent) {
     // back to the raw (empty) attrs to avoid leaking parent props onto native
     // wrappers like `<p>` or `<ul>`.
     const rawHasAttrs = Object.keys(rawAttributes).length > 0;
-    const attributes = state.context.html
-        ? (rawHasAttrs ? state.renderData.props : rawAttributes)
-        : rawAttributes;
-    const hasOnlyTextChildren = children.every(child => typeof child === 'string' || inlineTags.has(String(child?.[0])));
-    const hasTextSibling = children.some(child => typeof child === 'string');
+    const attributes = state.context.html ? (rawHasAttrs ? state.renderData.props : rawAttributes) : rawAttributes;
+    const hasOnlyTextChildren = children.every((child) => typeof child === 'string' || inlineTags.has(String(child?.[0])));
+    const hasTextSibling = children.some((child) => typeof child === 'string');
     const isBlock = textBlocks.has(String(tag));
     const isInline = inlineTags.has(String(tag)) && $.block === 0;
     let oneLiner = isBlock && hasOnlyTextChildren;
@@ -48,7 +62,8 @@ export async function html(node, state, parent) {
     for (let i = 0; i < children.length; i++) {
         const childContent = childrenContent[i];
         const child = children[i];
-        const isBlock = typeof child !== 'string' && (blockTags.has(String(child?.[0])) || (!inlineTags.has(String(child?.[0])) && !hasTextSibling));
+        const isBlock = typeof child !== 'string' &&
+            (blockTags.has(String(child?.[0])) || (!inlineTags.has(String(child?.[0])) && !hasTextSibling));
         if (i > 0 && !isPrevBlock && isBlock) {
             content += state.context.blockSeparator;
         }
@@ -62,23 +77,18 @@ export async function html(node, state, parent) {
     if (revert) {
         state.applyContext(revert);
     }
-    const attrs = Object.keys(attributes).length > 0
-        ? ` ${htmlAttributes(attributes)}`
-        : '';
+    const attrs = Object.keys(attributes).length > 0 ? ` ${htmlAttributes(attributes)}` : '';
     if (isSelfClose) {
         return `<${tag}${attrs} />` + (!parent && !isInline ? state.context.blockSeparator : '');
     }
     if (!oneLiner && content) {
         content = '\n' + paddNoneHtmlContent(content, state).trimEnd() + '\n';
     }
-    return `<${tag}${attrs}>${content}</${tag}>`
-        + (!parent && !isInline ? state.context.blockSeparator : '');
+    return `<${tag}${attrs}>${content}</${tag}>` + (!parent && !isInline ? state.context.blockSeparator : '');
 }
 function paddNoneHtmlContent(content, state) {
     if (state.context.html) {
         return indent(content);
     }
-    return ((content.trim().startsWith('<') ? '' : '')
-        + content
-        + (content.trim().endsWith('>') ? '' : ''));
+    return (content.trim().startsWith('<') ? '' : '') + content + (content.trim().endsWith('>') ? '' : '');
 }

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

@@ -2,8 +2,6 @@ import { comarkAttributes } from "../attributes.js";
 export function img(node, _state) {
     const [_, attrs] = node;
     const { title, src, alt = '', ...rest } = attrs;
-    const attrsString = Object.keys(rest).length > 0
-        ? comarkAttributes(rest)
-        : '';
+    const attrsString = Object.keys(rest).length > 0 ? comarkAttributes(rest) : '';
     return title ? `![${alt}](${src} "${title}")` : `![${alt}](${src})${attrsString}`;
 }

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

@@ -1,4 +1,4 @@
-import { indent } from "../indent.js";
+import { indent } from "../../../utils/index.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']);
@@ -18,14 +18,20 @@ export async function li(node, state) {
     let result = '';
     for (const child of children) {
         const rendered = await state.one(child, state, node);
-        if (Array.isArray(child) && 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 });
-            result = result.trimEnd() + '\n' + indented.trimEnd() + '\n';
-        }
-        else {
-            result += rendered;
+        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 });
+                result = result.trimEnd() + '\n' + indented.trimEnd() + '\n';
+                continue;
+            }
+            if (child[0] === 'p') {
+                const indented = indent(rendered, { width: prefixWidth });
+                result = result.trimEnd() + '\n\n' + indented.trimEnd() + '\n';
+                continue;
+            }
         }
+        result += rendered;
     }
     result = result.trim();
     if (!order) {

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

@@ -1,4 +1,4 @@
-import { indent } from "../indent.js";
+import { indent } from "../../../utils/index.js";
 import { comarkAttributes, comarkYamlAttributes } from "../attributes.js";
 import { html } from "./html.js";
 // HTML elements that always create an inline context for their children
@@ -28,8 +28,7 @@ export async function mdc(node, state, parent) {
     content = content.trimEnd();
     const attrs = attributeEntries.length > 0 ? comarkAttributes(attributes) : '';
     if (tag === 'span') {
-        return `[${content}]${attrs}`
-            + (inline ? '' : state.context.blockSeparator);
+        return `[${content}]${attrs}` + (inline ? '' : state.context.blockSeparator);
     }
     const fence = ':'.repeat((state.nodeDepthInTree || 0) + 2);
     let result = `:${tag}${content && `[${content}]`}${attrs}` + (!parent ? state.context.blockSeparator : '');

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

@@ -1,4 +1,4 @@
-import { indent } from "../indent.js";
+import { indent } from "../../../utils/index.js";
 export async function ol(node, state) {
     const children = node.slice(2);
     const revert = state.applyContext({ list: true, order: 1, listIndent: 3 });

package/dist/internal/stringify/handlers/p.d.ts

@@ -1,3 +1,3 @@
 import type { State } from 'comark/render';
 import type { ComarkElement } from 'comark';
-export declare function p(node: ComarkElement, state: State): Promise<string>;
+export declare function p(node: ComarkElement, state: State, parent?: ComarkElement): Promise<string>;

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

@@ -1,8 +1,11 @@
-export async function p(node, state) {
+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);
     }
+    if (parent?.[0] === 'li') {
+        return result;
+    }
     return result + state.context.blockSeparator;
 }

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

@@ -2,21 +2,18 @@ import { textContent } from "../../../utils/index.js";
 export function pre(node, state) {
     const [_, attributes, ...children] = node;
     const codeClasses = children[0]?.[1]?.class;
-    const language = (attributes.language || (codeClasses?.split(' ').find(cls => cls.startsWith('language-')))?.slice(9)) || '';
+    const language = attributes.language ||
+        codeClasses
+            ?.split(' ')
+            .find((cls) => cls.startsWith('language-'))
+            ?.slice(9) ||
+        '';
     // Escape ] in filename
-    const filename = attributes.filename
-        ? ' [' + String(attributes.filename).split(']').join('\\\\]') + ']'
-        : '';
-    const highlights = attributes.highlights
-        ? ' {' + formatHighlights(attributes.highlights) + '}'
-        : '';
+    const filename = attributes.filename ? ' [' + String(attributes.filename).split(']').join('\\\\]') + ']' : '';
+    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```';
+    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;
 }
 function formatHighlights(highlights) {

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

@@ -6,8 +6,6 @@ export async function strong(node, state) {
         content += await state.one(child, state, node);
     }
     content = content.trim();
-    const attrsString = Object.keys(attrs).length > 0
-        ? comarkAttributes(attrs)
-        : '';
+    const attrsString = Object.keys(attrs).length > 0 ? comarkAttributes(attrs) : '';
     return `**${content}**${attrsString}`;
 }

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

@@ -52,14 +52,14 @@ function getRows(element) {
     }
     // If it's thead/tbody, extract tr elements
     if (tag === 'thead' || tag === 'tbody') {
-        return children.filter(child => typeof child !== 'string' && child[0] === 'tr');
+        return children.filter((child) => typeof child !== 'string' && child[0] === 'tr');
     }
     return [];
 }
 // Helper function to get cells from a row
 function getCells(row) {
     const [, , ...children] = row;
-    return children.filter(child => typeof child !== 'string' && (child[0] === 'th' || child[0] === 'td'));
+    return children.filter((child) => typeof child !== 'string' && (child[0] === 'th' || child[0] === 'td'));
 }
 export async function table(node, state) {
     const [, , ...children] = node;
@@ -110,7 +110,7 @@ export async function table(node, state) {
         return getAlignment(attributes);
     });
     // Calculate column widths (minimum 3 characters per column)
-    const columnWidths = headerContent.map(content => Math.max(3, content.length));
+    const columnWidths = headerContent.map((content) => Math.max(3, content.length));
     // Update column widths based on body content
     for (const row of bodyRows) {
         const cells = getCells(row);
@@ -127,7 +127,8 @@ export async function table(node, state) {
     result += ' |\n';
     // Add separator row with alignment
     result += '| ';
-    result += columnWidths.map((width, i) => {
+    result += columnWidths
+        .map((width, i) => {
         const alignment = alignments[i];
         if (alignment === 'left') {
             return ':' + '-'.repeat(width - 1);
@@ -139,7 +140,8 @@ export async function table(node, state) {
             return '-'.repeat(width - 1) + ':';
         }
         return '-'.repeat(width);
-    }).join(' | ');
+    })
+        .join(' | ');
     result += ' |\n';
     // Add body rows
     for (const row of bodyRows) {

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

@@ -5,7 +5,7 @@ export async function template(node, state, parent) {
     // Omit #default marker if this is the only slot
     if (attrs.name === 'default') {
         const siblings = parent ? parent.slice(2) : [];
-        const templateCount = siblings.filter(child => Array.isArray(child) && child[0] === 'template').length;
+        const templateCount = siblings.filter((child) => Array.isArray(child) && child[0] === 'template').length;
         if (templateCount === 1) {
             return content + state.context.blockSeparator;
         }

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

@@ -1,4 +1,4 @@
-import { indent } from "../indent.js";
+import { indent } from "../../../utils/index.js";
 export async function ul(node, state) {
     const children = node.slice(2);
     const revert = state.applyContext({ list: true, order: false, listIndent: 2 });

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

@@ -1,5 +1 @@
-export declare function indent(text: string, { ignoreFirstLine, level, width }?: {
-    ignoreFirstLine?: boolean;
-    level?: number;
-    width?: number;
-}): string;
+export * from '../../../src/internal/stringify/indent'

package/dist/internal/stringify/indent.js

@@ -1,9 +1 @@
-export function indent(text, { ignoreFirstLine = false, level = 1, width } = {}) {
-    const pad = width ? ' '.repeat(width) : '  '.repeat(level);
-    return text.split('\n').map((line, index) => {
-        if (ignoreFirstLine && index === 0) {
-            return line;
-        }
-        return line ? pad + line : line;
-    }).join('\n');
-}
+export * from '../../../src/internal/stringify/indent.ts'

package/dist/internal/stringify/state.js

@@ -173,5 +173,5 @@ function escapeHtml(text) {
         '>': '>',
         '&': '&',
     };
-    return text.replace(/[<>]/g, char => map[char]);
+    return text.replace(/[<>]/g, (char) => map[char]);
 }

package/dist/internal/yaml.js

@@ -36,7 +36,7 @@ export function stringifyYaml(data, options) {
         const line = lines[i];
         const trimmed = line.trimStart();
         // Check if line starts with a quote followed by colon
-        if (trimmed[0] === '\'' || trimmed[0] === '"') {
+        if (trimmed[0] === "'" || trimmed[0] === '"') {
             const quote = trimmed[0];
             if (trimmed[1] === ':') {
                 // Find the closing quote

package/dist/parse.js

@@ -1,5 +1,5 @@
 import MarkdownExit from 'markdown-exit';
-import pluginMdc from '@comark/markdown-it';
+import syntax from "./plugins/syntax.js";
 import taskList from "./plugins/task-list.js";
 import alert from "./plugins/alert.js";
 import { applyAutoUnwrap } from "./internal/parse/auto-unwrap.js";
@@ -45,14 +45,13 @@ export { defineComarkPlugin } from "./utils/helpers.js";
  */
 export function createParse(options = {}) {
     const { autoUnwrap = true, autoClose = true, plugins = [] } = options;
+    plugins.unshift(syntax());
     plugins.unshift(taskList());
     plugins.unshift(alert());
     const parser = new MarkdownExit({
         html: false,
         linkify: true,
-    })
-        .enable(['table', 'strikethrough'])
-        .use(pluginMdc);
+    }).enable(['table', 'strikethrough']);
     if (options.html !== false) {
         parser.inline.ruler.before('text', 'comark_html_inline', html_inline);
         parser.block.ruler.before('html_block', 'comark_html_block', html_block, {
@@ -60,7 +59,7 @@ export function createParse(options = {}) {
         });
     }
     for (const plugin of plugins) {
-        for (const markdownItPlugin of (plugin.markdownItPlugins || [])) {
+        for (const markdownItPlugin of plugin.markdownItPlugins || []) {
             parser.use(markdownItPlugin);
         }
     }
@@ -76,7 +75,8 @@ export function createParse(options = {}) {
             reusableNodes: [],
         };
         const prevOutput = lastOutput;
-        if (opts.streaming && prevOutput && markdown.startsWith(lastInput ?? '')) {
+        const isStartsWithLastInput = markdown.startsWith(lastInput ?? '');
+        if (opts.streaming && prevOutput && isStartsWithLastInput) {
             const { remainingMarkdownStartLine, reusedNodes, remainingMarkdown } = extractReusableNodes(markdown, prevOutput);
             // If there is no remaining markdown, return the previous output
             if (!remainingMarkdown)
@@ -91,7 +91,13 @@ export function createParse(options = {}) {
         for (const plugin of options.plugins || []) {
             await plugin.pre?.(state);
         }
-        const { content, data } = parseFrontmatter(state.markdown);
+        const { content, data, frontmatterText } = parseFrontmatter(state.markdown);
+        // Count frontmatter lines for line number tracking
+        if (content && frontmatterText) {
+            state.parsedLines +=
+                frontmatterText.split('\n').length + // Number of lines in frontmatter
+                    1; // Separator line
+        }
         try {
             state.tokens = parser.parse(content, {});
         }
@@ -114,7 +120,7 @@ export function createParse(options = {}) {
         }
         if (opts.streaming) {
             state.tree = {
-                frontmatter: state.parsedLines > 0 ? (prevOutput?.frontmatter ?? data) : data,
+                frontmatter: frontmatterText ? data : (prevOutput?.frontmatter ?? data),
                 meta: {},
                 nodes: [...state.reusableNodes, ...nodes],
             };

package/dist/plugins/alert.js

@@ -30,7 +30,7 @@ const markers = {
 export default defineComarkPlugin(() => ({
     name: 'alert',
     post(state) {
-        visit(state.tree, node => Array.isArray(node) && node[0] === 'blockquote', (node) => {
+        visit(state.tree, (node) => Array.isArray(node) && node[0] === 'blockquote', (node) => {
             const element = node;
             if (node[2]?.[0] === 'span') {
                 const content = String(node[2][2]).toUpperCase();

package/dist/plugins/binding.js

@@ -36,9 +36,7 @@ const markdownItInlineBinding = (md, options = {}) => {
 export default defineComarkPlugin((opts = {}) => {
     return {
         name: 'binding',
-        markdownItPlugins: [
-            ((md) => markdownItInlineBinding(md, opts)),
-        ],
+        markdownItPlugins: [((md) => markdownItInlineBinding(md, opts))],
     };
 });
 /**

package/dist/plugins/breaks.js

@@ -3,7 +3,7 @@ import { visit } from "../utils/index.js";
 export default defineComarkPlugin(() => ({
     name: 'breaks',
     post(state) {
-        visit(state.tree, node => Array.isArray(node) && node.length > 2, (node) => {
+        visit(state.tree, (node) => Array.isArray(node) && node.length > 2, (node) => {
             const parent = node;
             const newParent = [parent[0], parent[1]];
             let hasModified = false;

package/dist/plugins/emoji.js

@@ -386,7 +386,7 @@ const emojiRule = (state, silent) => {
     const max = state.posMax;
     const start = state.pos;
     // Quick check: must start with ':'
-    if (state.src.charCodeAt(start) !== 0x3A /* : */) {
+    if (state.src.charCodeAt(start) !== 0x3a /* : */) {
         return false;
     }
     // Find the closing ':'
@@ -394,7 +394,7 @@ const emojiRule = (state, silent) => {
     while (pos < max) {
         const code = state.src.charCodeAt(pos);
         // Found closing ':'
-        if (code === 0x3A /* : */) {
+        if (code === 0x3a /* : */) {
             const emojiName = state.src.slice(start + 1, pos);
             // Check if this is a valid emoji
             const emojiChar = EMOJI_MAP.get(emojiName);
@@ -412,12 +412,12 @@ const emojiRule = (state, silent) => {
         }
         // Only allow word characters, digits, underscores, hyphens, and plus
         // This matches the pattern of valid emoji names
-        if ((code >= 0x61 && code <= 0x7A) // a-z
-            || (code >= 0x41 && code <= 0x5A) // A-Z
-            || (code >= 0x30 && code <= 0x39) // 0-9
-            || code === 0x5F // _
-            || code === 0x2D // -
-            || code === 0x2B // +
+        if ((code >= 0x61 && code <= 0x7a) || // a-z
+            (code >= 0x41 && code <= 0x5a) || // A-Z
+            (code >= 0x30 && code <= 0x39) || // 0-9
+            code === 0x5f || // _
+            code === 0x2d || // -
+            code === 0x2b // +
         ) {
             pos++;
             continue;

package/dist/plugins/footnotes.js

@@ -9,10 +9,7 @@ const FOOTNOTE_DEF_RE = /^\[\^([^\s\]]+)\]:[ \t]?(.*)$/gm;
  * on every node in the tree.
  */
 function maybeFootnoteRef(node) {
-    return Array.isArray(node)
-        && node[0] === 'span'
-        && node.length === 3
-        && typeof node[2] === 'string';
+    return Array.isArray(node) && node[0] === 'span' && node.length === 3 && typeof node[2] === 'string';
 }
 /**
  * Check if a node is a footnote reference: ['span', {}, '^label']
@@ -29,12 +26,12 @@ function isFootnoteRef(node) {
     }
     const child = node[2];
     // Must start with '^' and have at least one label char
-    if (child.charCodeAt(0) !== 0x5E /* ^ */ || child.length < 2)
+    if (child.charCodeAt(0) !== 0x5e /* ^ */ || child.length < 2)
         return null;
     // Check for whitespace using charCode scanning (avoid regex)
     for (let i = 1; i < child.length; i++) {
         const c = child.charCodeAt(i);
-        if (c === 0x20 || c === 0x09 || c === 0x0A || c === 0x0D)
+        if (c === 0x20 || c === 0x09 || c === 0x0a || c === 0x0d)
             return null;
     }
     return child.slice(1);
@@ -59,7 +56,7 @@ function isFootnoteRef(node) {
  * ```
  */
 export default defineComarkPlugin((config = {}) => {
-    const { label = 'Footnotes', hr = true, backRef = '↩', } = config;
+    const { label = 'Footnotes', hr = true, backRef = '↩' } = config;
     return {
         name: 'footnotes',
         // extract footnote definitions from markdown before MDC parsing
@@ -88,11 +85,17 @@ export default defineComarkPlugin((config = {}) => {
                     refIndexMap.set(refLabel, refIndexMap.size + 1);
                 }
                 const refIndex = refIndexMap.get(refLabel);
-                return ['sup', { class: 'footnote-ref' },
-                    ['a', {
+                return [
+                    'sup',
+                    { class: 'footnote-ref' },
+                    [
+                        'a',
+                        {
                             href: `#fn-${refLabel}`,
                             id: `fnref-${refLabel}`,
-                        }, `[${refIndex}]`],
+                        },
+                        `[${refIndex}]`,
+                    ],
                 ];
             });
             let nodes = state.tree.nodes;
@@ -121,8 +124,11 @@ export default defineComarkPlugin((config = {}) => {
             const footnoteItems = [];
             for (const [refLabel] of refIndexMap) {
                 const content = definitions.get(refLabel);
-                footnoteItems.push(['li', { id: `fn-${refLabel}` },
-                    content, ' ',
+                footnoteItems.push([
+                    'li',
+                    { id: `fn-${refLabel}` },
+                    content,
+                    ' ',
                     ['a', { href: `#fnref-${refLabel}`, class: 'footnote-backref' }, backRef],
                 ]);
             }
@@ -166,7 +172,7 @@ export const Footnote = {
     },
     handler: (node) => {
         if (node[1].class === 'footnotes') {
-            const ol = node.find(n => Array.isArray(n) && n[0] === 'ol');
+            const ol = node.find((n) => Array.isArray(n) && n[0] === 'ol');
             if (!ol)
                 return '';
             let result = '';

package/dist/plugins/headings.js

@@ -57,7 +57,7 @@ export default defineComarkPlugin((options = {}) => {
         post(state) {
             const nodes = state.tree.nodes;
             // Top-level content nodes — skip raw text nodes and <hr>
-            const contentNodes = nodes.filter(node => Array.isArray(node) && getTag(node) !== 'hr');
+            const contentNodes = nodes.filter((node) => Array.isArray(node) && getTag(node) !== 'hr');
             let titleNodeIndex = -1;
             let descriptionNodeIndex = -1;
             const first = contentNodes[0];
@@ -74,9 +74,7 @@ export default defineComarkPlugin((options = {}) => {
             }
             if (remove) {
                 // Remove in reverse order to preserve indices
-                const toRemove = [titleNodeIndex, descriptionNodeIndex]
-                    .filter(i => i !== -1)
-                    .sort((a, b) => b - a);
+                const toRemove = [titleNodeIndex, descriptionNodeIndex].filter((i) => i !== -1).sort((a, b) => b - a);
                 for (const i of toRemove) {
                     nodes.splice(i, 1);
                 }

package/dist/plugins/highlight.d.ts

@@ -1,5 +1,5 @@
 import type { LanguageRegistration, ShikiTransformer, ShikiPrimitive, ThemeRegistration } from 'shiki';
-import type { ComarkNode, ComarkTree } from 'comark';
+import type { ComarkTree } from 'comark';
 export interface HighlightOptions {
     /**
      * Whether to use the default language definitions
@@ -46,16 +46,6 @@ export interface CodeBlockAttributes {
  * Uses a singleton pattern to avoid creating multiple highlighters
  */
 export declare function getHighlighter(options?: HighlightOptions): Promise<ShikiPrimitive>;
-/**
- * Highlight code using Shiki with codeToTokens
- * Returns comark nodes built from hast
- */
-export declare function highlightCode(code: string, attrs: CodeBlockAttributes, options?: HighlightOptions): Promise<{
-    nodes: ComarkNode[];
-    language: string;
-    bgColor?: string;
-    fgColor?: string;
-}>;
 /**
  * Apply syntax highlighting to all code blocks in a Comark tree
  * Uses codeToTokens API with batched async operations