comark 0.3.0 → 0.3.2

package/dist/plugins/syntax.d.ts

@@ -0,0 +1,49 @@
+import type { MarkdownItPluginWithOptions } from '../types.ts';
+export interface SyntaxOptions {
+    /**
+     * Enable block component syntax.
+     *
+     * @see https://comark.dev/syntax/components#block
+     * @default true
+     */
+    blockComponent?: boolean;
+    /**
+     * Enable inline props syntax.
+     *
+     * @see https://comark.dev/syntax/attributes
+     * @default true
+     */
+    inlineProps?: boolean;
+    /**
+     * Enable inline span syntax.
+     *
+     * @see https://comark.dev/syntax/attributes#span-attributes
+     * @default true
+     */
+    inlineSpan?: boolean;
+    /**
+     * Enable inline component syntax.
+     *
+     * @see https://comark.dev/syntax/components#inline
+     * @default true
+     */
+    inlineComponent?: boolean;
+    /**
+     * Enable inline binding syntax (`{{ value }}` and `{{ value || default }}`).
+     *
+     * Off by default — opt in here, or use the standalone `plugins/binding.ts` plugin.
+     *
+     * @see https://comark.dev/syntax/components#data-binding
+     * @default false
+     */
+    inlineBinding?: boolean;
+    /**
+     * The tag name used to render an inline binding.
+     *
+     * @default 'binding'
+     */
+    bindingTag?: string;
+}
+declare const _default: import("../types.ts").ComarkPluginFactory<SyntaxOptions>;
+export default _default;
+export declare const markdownItComark: MarkdownItPluginWithOptions<SyntaxOptions>;

package/dist/plugins/syntax.js

@@ -0,0 +1,522 @@
+import { Token } from 'markdown-exit';
+import { defineComarkPlugin } from "../utils/helpers.js";
+import { parseBracketContent } from "../internal/parse/syntax/brackets.js";
+import { searchProps } from "../internal/parse/syntax/props.js";
+import { parseBlockParams } from "../internal/parse/syntax/block-params.js";
+import { parseYaml } from "../internal/yaml.js";
+// #region Block component plugin (`::name` and `::name ... ::`)
+const blockYamlLines = {
+    '---': '---',
+    '```yaml [props]': '```',
+    '~~~yaml [props]': '~~~',
+    '```yml [props]': '```',
+    '~~~yml [props]': '~~~',
+};
+const markdownItComarkBlock = (md) => {
+    const min_markers = 2;
+    const marker_str = ':';
+    const marker_char = marker_str.charCodeAt(0);
+    md.block.ruler.before('fence', 'comark_block_shorthand', function comark_block_shorthand(state, startLine, _endLine, silent) {
+        const line = state.src.slice(state.bMarks[startLine] + state.tShift[startLine], state.eMarks[startLine]);
+        if (!/^:\w/.test(line))
+            return false;
+        const { name, content, props, remaining } = parseBlockParams(line.slice(1));
+        // If there's unparsed remaining content, treat it as inline component in a paragraph
+        if (remaining)
+            return false;
+        state.lineMax = startLine + 1;
+        if (!silent) {
+            if (content !== undefined) {
+                const tokenOpen = state.push('mdc_block_shorthand', name, 1);
+                props?.forEach(([key, value]) => {
+                    if (key === 'class')
+                        tokenOpen.attrJoin(key, value);
+                    else
+                        tokenOpen.attrSet(key, value);
+                });
+                tokenOpen.map = [startLine, startLine + 1];
+                const inline = state.push('inline', '', 0);
+                inline.content = content;
+                inline.children = [];
+                const tokenClose = state.push('mdc_block_shorthand', name, -1);
+                tokenClose.map = [startLine, startLine + 1];
+            }
+            else {
+                const token = state.push('mdc_block_shorthand', name, 0);
+                token.map = [startLine, startLine + 1];
+                props?.forEach(([key, value]) => {
+                    if (key === 'class')
+                        token.attrJoin(key, value);
+                    else
+                        token.attrSet(key, value);
+                });
+            }
+        }
+        state.line = startLine + 1;
+        return true;
+    });
+    md.block.ruler.before('fence', 'comark_block', function comark_block(state, startLine, endLine, silent) {
+        let pos;
+        let nextLine;
+        let auto_closed = false;
+        let start = state.bMarks[startLine] + state.tShift[startLine];
+        let max = state.eMarks[startLine];
+        const indent = state.sCount[startLine];
+        // Track code fences (``` or ~~~) so we don't match closing :: inside them
+        let inCodeFence = false;
+        let codeFenceCharCode = 0;
+        let codeFenceCount = 0;
+        // Track nesting depth for blocks with the same marker count
+        let nestingDepth = 0;
+        if (state.src[start] !== ':')
+            return false;
+        for (pos = start + 1; pos <= max; pos++) {
+            if (marker_str !== state.src[pos])
+                break;
+        }
+        const marker_count = Math.floor(pos - start);
+        if (marker_count < min_markers)
+            return false;
+        const markup = state.src.slice(start, pos);
+        const params = parseBlockParams(state.src.slice(pos, max));
+        if (!params.name)
+            return false;
+        if (silent)
+            return true;
+        nextLine = startLine;
+        for (;;) {
+            nextLine++;
+            if (nextLine >= endLine)
+                break;
+            start = state.bMarks[nextLine] + state.tShift[nextLine];
+            max = state.eMarks[nextLine];
+            if (start < max && state.sCount[nextLine] < state.blkIndent)
+                break;
+            const lineCharCode = state.src.charCodeAt(start);
+            // Detect closing code fence (``` or ~~~)
+            if (inCodeFence) {
+                if (lineCharCode === codeFenceCharCode) {
+                    let fencePos = start + 1;
+                    while (fencePos < max && state.src.charCodeAt(fencePos) === codeFenceCharCode)
+                        fencePos++;
+                    if (fencePos - start >= codeFenceCount) {
+                        const afterFence = state.skipSpaces(fencePos);
+                        if (afterFence >= max)
+                            inCodeFence = false;
+                    }
+                }
+                continue;
+            }
+            // Detect opening code fence (``` or ~~~)
+            if (lineCharCode === 0x60 /* ` */ || lineCharCode === 0x7e /* ~ */) {
+                let fencePos = start + 1;
+                while (fencePos < max && state.src.charCodeAt(fencePos) === lineCharCode)
+                    fencePos++;
+                if (fencePos - start >= 3) {
+                    inCodeFence = true;
+                    codeFenceCharCode = lineCharCode;
+                    codeFenceCount = fencePos - start;
+                    continue;
+                }
+            }
+            if (marker_char !== lineCharCode)
+                continue;
+            for (pos = start + 1; pos <= max; pos++) {
+                if (marker_str !== state.src[pos])
+                    break;
+            }
+            // Closing fence must match the opening fence length
+            if (pos - start !== marker_count)
+                continue;
+            pos = state.skipSpaces(pos);
+            if (pos < max) {
+                // A new nested block opens with same marker count
+                nestingDepth++;
+                continue;
+            }
+            if (nestingDepth > 0) {
+                nestingDepth--;
+                continue;
+            }
+            auto_closed = true;
+            break;
+        }
+        const old_parent = state.parentType;
+        const old_line_max = state.lineMax;
+        state.parentType = 'comark_block';
+        // Prevent lazy continuations from going past our end marker
+        state.lineMax = nextLine;
+        const tokenOpen = state.push('mdc_block_open', params.name, 1);
+        tokenOpen.markup = markup;
+        tokenOpen.block = true;
+        tokenOpen.info = params.name;
+        tokenOpen.map = [startLine, nextLine];
+        params.props?.forEach(([key, value]) => {
+            if (key === 'class')
+                tokenOpen.attrJoin(key, value);
+            else
+                tokenOpen.attrSet(key, value);
+        });
+        // Render bracket content as the first paragraph: `::block[Content]\n::`
+        if (params.content !== undefined) {
+            const pOpen = state.push('paragraph_open', 'p', 1);
+            pOpen.map = [startLine, startLine + 1];
+            const inline = state.push('inline', '', 0);
+            inline.content = params.content;
+            inline.children = [];
+            state.push('paragraph_close', 'p', -1);
+        }
+        const blkIndent = state.blkIndent;
+        state.blkIndent = indent;
+        state.env.comarkBlockTokens ||= [];
+        state.env.comarkBlockTokens.unshift(tokenOpen);
+        state.md.block.tokenize(state, startLine + 1, nextLine);
+        state.blkIndent = blkIndent;
+        state.env.comarkBlockTokens.shift();
+        const tokenClose = state.push('mdc_block_close', params.name, -1);
+        tokenClose.map = [startLine, nextLine];
+        tokenClose.markup = state.src.slice(start, pos);
+        tokenClose.block = true;
+        // Hide the wrapper paragraph for single-paragraph blocks
+        state.tokens
+            .slice(state.tokens.indexOf(tokenOpen) + 1, state.tokens.indexOf(tokenClose))
+            .filter((i) => i.level === tokenOpen.level + 1)
+            .forEach((i, _, arr) => {
+            if (arr.length <= 2 && i.tag === 'p')
+                i.hidden = true;
+        });
+        state.parentType = old_parent;
+        state.lineMax = old_line_max;
+        state.line = nextLine + (auto_closed ? 1 : 0);
+        return true;
+    }, {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.block.ruler.after('code', 'comark_block_yaml', function comark_block_yaml(state, startLine, endLine, silent) {
+        if (!state.env.comarkBlockTokens?.length)
+            return false;
+        const start = state.bMarks[startLine] + state.tShift[startLine];
+        const end = state.eMarks[startLine];
+        const line = state.src.slice(start, end);
+        const blockAttributesClosingFence = blockYamlLines[line] || '';
+        if (!blockAttributesClosingFence)
+            return false;
+        let lineEnd = startLine + 1;
+        let found = false;
+        while (lineEnd < endLine) {
+            const inner = state.src.slice(state.bMarks[lineEnd] + state.tShift[startLine], state.eMarks[lineEnd]);
+            if (inner === blockAttributesClosingFence) {
+                found = true;
+                break;
+            }
+            lineEnd += 1;
+        }
+        if (!found)
+            return false;
+        if (!silent) {
+            const yaml = state.src.slice(state.bMarks[startLine + 1], state.eMarks[lineEnd - 1]);
+            const data = parseYaml(yaml);
+            const token = state.env.comarkBlockTokens[0];
+            Object.entries(data || {}).forEach(([key, value]) => {
+                if (key === 'class')
+                    token.attrJoin(key, value);
+                else
+                    token.attrSet(key, typeof value === 'string' ? value : JSON.stringify(value));
+            });
+        }
+        state.line = lineEnd + 1;
+        state.lineMax = lineEnd + 1;
+        return true;
+    });
+    md.block.ruler.after('code', 'comark_block_slots', function comark_block_slots(state, startLine, endLine, silent) {
+        if (!state.env.comarkBlockTokens?.length)
+            return false;
+        const start = state.bMarks[startLine] + state.tShift[startLine];
+        if (!(state.src[start] === '#' && state.src[start + 1] !== ' ' && state.src[start + 1] !== '#'))
+            return false;
+        const line = state.src.slice(start, state.eMarks[startLine]);
+        const { name, props } = parseBlockParams(line.slice(1));
+        let lineEnd = startLine + 1;
+        while (lineEnd < endLine) {
+            const inner = state.src.slice(state.bMarks[lineEnd] + state.tShift[startLine], state.eMarks[lineEnd]);
+            if (/^#\w+/.test(inner) || inner.startsWith('::'))
+                break;
+            lineEnd += 1;
+        }
+        if (silent) {
+            state.line = lineEnd;
+            state.lineMax = lineEnd;
+            return true;
+        }
+        state.lineMax = startLine + 1;
+        const slot = state.push('mdc_block_slot', 'template', 1);
+        slot.attrSet(`#${name}`, '');
+        props?.forEach(([key, value]) => {
+            if (key === 'class')
+                slot.attrJoin(key, value);
+            else
+                slot.attrSet(key, value);
+        });
+        state.line = startLine + 1;
+        state.lineMax = lineEnd;
+        state.md.block.tokenize(state, startLine + 1, lineEnd);
+        state.push('mdc_block_slot', 'template', -1);
+        state.line = lineEnd;
+        state.lineMax = lineEnd;
+        return true;
+    });
+};
+// #endregion
+// #region Inline span plugin (`[text]`)
+const markdownItInlineSpan = (md) => {
+    md.inline.ruler.before('link', 'comark_inline_span', (state, silent) => {
+        const start = state.pos;
+        if (state.src[start] !== '[')
+            return false;
+        let index = start + 1;
+        let depth = 0;
+        while (index < state.src.length) {
+            if (state.src[index] === '\\') {
+                index += 2;
+                continue;
+            }
+            if (state.src[index] === '[') {
+                depth++;
+            }
+            else if (state.src[index] === ']') {
+                if (depth === 0)
+                    break;
+                depth--;
+            }
+            index += 1;
+        }
+        if (index === start)
+            return false;
+        // Don't match `[text](url)` or `[text][ref]` — let the link parser handle those
+        const nextChar = state.src[index + 1];
+        if (nextChar === '(' || nextChar === '[')
+            return false;
+        if (silent)
+            return true;
+        state.push('mdc_inline_span', 'span', 1);
+        const oldPos = state.pos;
+        const oldPosMax = state.posMax;
+        state.pos = start + 1;
+        state.posMax = index;
+        state.md.inline.tokenize(state);
+        state.pos = oldPos;
+        state.posMax = oldPosMax;
+        state.push('mdc_inline_span', 'span', -1);
+        state.pos = index + 1;
+        return true;
+    });
+};
+// #endregion
+// #region Inline component plugin (`:name[content]{props}`)
+const ALLOWED_PREV_CHARS = new Set([' ', '\t', '\n', '*', '_', '[']);
+const markdownItInlineComponent = (md) => {
+    md.inline.ruler.after('entity', 'comark_inline_component', (state, silent) => {
+        const start = state.pos;
+        if (state.src[start] !== ':')
+            return false;
+        const prevChar = state.src[start - 1];
+        if (start > 0 && !ALLOWED_PREV_CHARS.has(prevChar))
+            return false;
+        let index = start + 1;
+        let nameEnd = -1;
+        let contentStart = -1;
+        let contentEnd = -1;
+        while (index < state.src.length) {
+            const char = state.src[index];
+            if (char === '[') {
+                nameEnd = index;
+                const result = parseBracketContent(state.src, index);
+                if (result) {
+                    contentStart = index + 1;
+                    contentEnd = result.endIndex - 1;
+                    index = result.endIndex;
+                }
+                break;
+            }
+            if (!/[\w$-]/.test(char))
+                break;
+            index += 1;
+        }
+        if (nameEnd === -1)
+            nameEnd = index;
+        // Empty name
+        if (nameEnd <= start + 1)
+            return false;
+        state.pos = index;
+        if (silent)
+            return true;
+        const name = state.src.slice(start + 1, nameEnd);
+        if (contentStart !== -1) {
+            state.push('mdc_inline_component', name, 1);
+            const oldPos = state.pos;
+            const oldPosMax = state.posMax;
+            state.pos = contentStart;
+            state.posMax = contentEnd;
+            state.md.inline.tokenize(state);
+            state.pos = oldPos;
+            state.posMax = oldPosMax;
+            state.push('mdc_inline_component', name, -1);
+        }
+        else {
+            state.push('mdc_inline_component', name, 0);
+        }
+        return true;
+    });
+};
+// #endregion
+// #region Inline props plugin (`{class="foo"}` after a token)
+const markdownItInlineProps = (md) => {
+    md.inline.ruler.after('entity', 'comark_inline_props', (state, silent) => {
+        const start = state.pos;
+        if (state.src[start] !== '{')
+            return false;
+        // Skip Vue mustache `{{ }}` and template `${ }` syntax
+        if (state.src[start + 1] === '{' || state.src[start - 1] === '{' || state.src[start - 1] === '$')
+            return false;
+        const search = searchProps(state.src, start);
+        if (!search)
+            return false;
+        const { props, index: end } = search;
+        if (end === start)
+            return false;
+        state.pos = end;
+        if (silent)
+            return true;
+        // Hidden token holding the props; later applied to the previous token
+        const token = state.push('mdc_inline_props', 'span', 0);
+        token.attrs = props;
+        token.hidden = true;
+        return true;
+    });
+    md.renderer.rules.mdc_inline_props = () => '';
+    const _parse = md.parse;
+    md.parse = function (src, env) {
+        const tokens = _parse.call(this, src, env);
+        // When the props token is the only inline child of a heading/paragraph/list_item,
+        // apply it to the parent block tag instead of producing a `span`
+        tokens.forEach((token, index) => {
+            const prev = tokens[index - 1];
+            const next = tokens[index + 1];
+            if (!prev || !['heading_open', 'paragraph_open', 'list_item_open'].includes(prev.type) || prev.hidden)
+                return;
+            // list item handling
+            if (token.hidden && next?.type === 'inline')
+                token = next;
+            if (token.type === 'inline' &&
+                token.children?.length === 2 &&
+                token.children[0].type === 'text' &&
+                token.children[1].type === 'mdc_inline_props') {
+                const props = token.children[1].attrs;
+                token.children.splice(1, 1);
+                props?.forEach(([key, value]) => {
+                    if (key === 'class')
+                        prev.attrJoin('class', value);
+                    else
+                        prev.attrSet(key, value);
+                });
+            }
+        });
+        // Deduplicate `ul` wrapping when `::ul` is used and contains exactly one bullet list
+        tokens.forEach((tokenOpen, index) => {
+            if (tokenOpen.type !== 'bullet_list_open')
+                return;
+            const prev = tokens[index - 1];
+            if (!prev || prev.type !== 'mdc_block_open' || prev.tag !== 'ul')
+                return;
+            let closeIndex = index + 1;
+            while (closeIndex < tokens.length) {
+                const close = tokens[closeIndex];
+                if (close.type === 'bullet_list_close' && close.level === tokenOpen.level)
+                    break;
+                closeIndex += 1;
+            }
+            const tokenClose = tokens[closeIndex];
+            if (tokenClose?.type !== 'bullet_list_close')
+                return;
+            const next = tokens[closeIndex + 1];
+            if (next?.type === 'mdc_block_close' && next.tag === 'ul') {
+                tokenOpen.hidden = true;
+                tokenClose.hidden = true;
+            }
+        });
+        return tokens;
+    };
+    md.renderer.renderInline = wrapRenderInline(md.renderer.renderInline);
+    // Support markdown-exit's async inline renderer
+    if ('renderInlineAsync' in md.renderer) {
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any -- mirrors the sync wrapper for the async overload
+        ;
+        md.renderer.renderInlineAsync = wrapRenderInline(md.renderer.renderInlineAsync);
+    }
+};
+function wrapRenderInline(renderInline) {
+    return function (tokens, options, env) {
+        tokens = [...tokens];
+        tokens.forEach((token, index) => {
+            if (token.type !== 'mdc_inline_props')
+                return;
+            let prevIndex = index - 1;
+            let prev = tokens[prevIndex];
+            // Skip whitespace-only text tokens
+            while (prevIndex >= 0) {
+                if (prev.type === 'text' && !prev.content.trim()) {
+                    prevIndex--;
+                    prev = tokens[prevIndex];
+                }
+                else {
+                    break;
+                }
+            }
+            // Wrap a bare text token in a span so we can attach attrs to it
+            if (!prev.tag && prev.type === 'text') {
+                prev = new Token('mdc_inline_span', 'span', 1);
+                tokens.splice(index - 1, 0, prev);
+                const close = new Token('mdc_inline_span', 'span', -1);
+                tokens.splice(index + 2, 0, close);
+            }
+            else if (prev.nesting === -1) {
+                // Resolve a closing tag back to its matching opening tag
+                let searchIndex = index - 1;
+                while (searchIndex >= 0) {
+                    const searchToken = tokens[searchIndex];
+                    if (searchToken.nesting === 1 && searchToken.tag === prev.tag && searchToken.level === prev.level) {
+                        prev = searchToken;
+                        break;
+                    }
+                    searchIndex--;
+                }
+            }
+            if (prev.nesting === -1)
+                throw new Error(`No matching opening tag found for ${JSON.stringify(prev)}`);
+            token.attrs?.forEach(([key, value]) => {
+                if (key === 'class')
+                    prev.attrJoin('class', value);
+                else
+                    prev.attrSet(key, value);
+            });
+        });
+        return renderInline.call(this, tokens, options, env);
+    };
+}
+// #endregion
+function applySyntax(md, options = {}) {
+    const { blockComponent = true, inlineProps = true, inlineSpan = true, inlineComponent = true } = options;
+    if (blockComponent)
+        md.use(markdownItComarkBlock);
+    if (inlineProps)
+        md.use(markdownItInlineProps);
+    if (inlineSpan)
+        md.use(markdownItInlineSpan);
+    if (inlineComponent)
+        md.use(markdownItInlineComponent);
+}
+export default defineComarkPlugin((options = {}) => ({
+    name: 'syntax',
+    markdownItPlugins: [((md) => applySyntax(md, options))],
+}));
+export const markdownItComark = applySyntax;

package/dist/plugins/task-list.d.ts

@@ -1,5 +1,5 @@
 /**
- * Custom task list plugin for markdown-it that works with @comark/markdown-it
+ * Custom task list plugin for markdown-it that integrates with the Comark syntax plugin.
  *
  * This plugin runs before inline parsing to prevent Comark from interpreting
  * task list markers [X] and [ ] as Comark inline span syntax.

package/dist/plugins/task-list.js

@@ -1,5 +1,5 @@
 /**
- * Custom task list plugin for markdown-it that works with @comark/markdown-it
+ * Custom task list plugin for markdown-it that integrates with the Comark syntax plugin.
  *
  * This plugin runs before inline parsing to prevent Comark from interpreting
  * task list markers [X] and [ ] as Comark inline span syntax.
@@ -35,8 +35,8 @@ function findParentList(tokens, listItemIndex) {
     const targetLevel = tokens[listItemIndex].level - 1;
     // Look backwards for the list (ul/ol) that contains this list item
     for (let i = listItemIndex - 1; i >= 0; i--) {
-        if (tokens[i].level === targetLevel
-            && (tokens[i].type === 'bullet_list_open' || tokens[i].type === 'ordered_list_open')) {
+        if (tokens[i].level === targetLevel &&
+            (tokens[i].type === 'bullet_list_open' || tokens[i].type === 'ordered_list_open')) {
             return i;
         }
     }
@@ -67,7 +67,7 @@ function markdownItTaskList(md, options) {
                         // Replace the task marker with a placeholder that won't be processed by Comark
                         // We use a special format that we can detect later
                         // Keep one space after the placeholder to match expected output
-                        const checkboxPlaceholder = `{{TASK_CHECKBOX_${isChecked ? 'CHECKED' : 'UNCHECKED'}}} `;
+                        const checkboxPlaceholder = `TASK_CHECKBOX_${isChecked ? 'CHECKED' : 'UNCHECKED'} `;
                         token.content = token.content.replace(/^\[[ x]\]\s+/i, checkboxPlaceholder);
                     }
                 }
@@ -85,13 +85,16 @@ function markdownItTaskList(md, options) {
                     const child = token.children[j];
                     if (child.type === 'text' && child.content) {
                         // Check for our checkbox placeholder
-                        const checkedMatch = child.content.match(/^\{\{TASK_CHECKBOX_CHECKED\}\}/);
-                        const uncheckedMatch = child.content.match(/^\{\{TASK_CHECKBOX_UNCHECKED\}\}/);
+                        const checkedMatch = child.content.match(/^TASK_CHECKBOX_CHECKED/);
+                        const uncheckedMatch = child.content.match(/^TASK_CHECKBOX_UNCHECKED/);
                         if (checkedMatch || uncheckedMatch) {
                             const isChecked = !!checkedMatch;
                             // Create checkbox token
                             const checkbox = new state.Token('mdc_inline_component', 'input', 0);
-                            checkbox.attrs = [['class', 'task-list-item-checkbox'], ['type', 'checkbox']];
+                            checkbox.attrs = [
+                                ['class', 'task-list-item-checkbox'],
+                                ['type', 'checkbox'],
+                            ];
                             if (disableCheckboxes) {
                                 checkbox.attrs.push([':disabled', 'true']);
                             }
@@ -99,7 +102,7 @@ function markdownItTaskList(md, options) {
                                 checkbox.attrs.push([':checked', 'true']);
                             }
                             // Remove placeholder from text
-                            child.content = child.content.replace(/^\{\{TASK_CHECKBOX_(CHECKED|UNCHECKED)\}\}/, '');
+                            child.content = child.content.replace(/^TASK_CHECKBOX_(CHECKED|UNCHECKED)/, '');
                             // Insert checkbox before the text
                             token.children.splice(j, 0, checkbox);
                             j++; // Skip the newly inserted checkbox

package/dist/plugins/toc.js

@@ -94,7 +94,7 @@ export function generateFlatToc(body, options) {
         const tag = getTag(node);
         return tag !== null && tags.includes(tag);
     });
-    const links = headers.map(node => ({
+    const links = headers.map((node) => ({
         id: getProps(node).id || '',
         depth: getHeaderDepth(node),
         text: flattenNodeText(node),

package/dist/types.d.ts

@@ -228,6 +228,7 @@ export interface NodeRenderData {
 }
 export type MarkdownExitPlugin = (md: MarkdownExit) => void;
 export type MarkdownItPlugin = (md: MarkdownIt) => void;
+export type MarkdownItPluginWithOptions<T> = (md: MarkdownIt, options: T) => void;
 export type ComarkParsePreState = {
     markdown: string;
     options: ParseOptions;