comark 0.3.1 → 0.4.0

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

@@ -1,11 +1,11 @@
-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
 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);
     }
@@ -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,5 @@
-import { indent } from "../indent.js";
+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 });
@@ -7,12 +8,21 @@ export async function ol(node, state) {
         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.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,15 @@
-export async function p(node, state) {
+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;
+    }
     return result + state.context.blockSeparator;
 }

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

@@ -1,23 +1,29 @@
 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;
-    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```';
-    return result + state.context.blockSeparator;
+    const meta = attributes.meta ? ' ' + attributes.meta : '';
+    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/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

@@ -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;
@@ -52,14 +53,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 +111,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 +128,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 +141,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) {
@@ -156,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;
@@ -5,10 +6,12 @@ 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;
         }
     }
-    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 "../indent.js";
+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

@@ -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.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>>>;

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";
@@ -44,15 +44,17 @@ export { defineComarkPlugin } from "./utils/helpers.js";
  * ```
  */
 export function createParse(options = {}) {
-    const { autoUnwrap = true, autoClose = true, plugins = [] } = options;
+    const { autoUnwrap = true, autoClose = true } = options;
+    // Make a mutable working copy so the inferred (possibly readonly) user tuple
+    // isn't mutated by the unshift calls below.
+    const plugins = options.plugins ? [...options.plugins] : [];
+    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,13 +62,13 @@ export function createParse(options = {}) {
         });
     }
     for (const plugin of plugins) {
-        for (const markdownItPlugin of (plugin.markdownItPlugins || [])) {
+        for (const markdownItPlugin of plugin.markdownItPlugins || []) {
             parser.use(markdownItPlugin);
         }
     }
     let lastOutput = null;
     let lastInput = null;
-    return async (markdown, opts = {}) => {
+    const parseFn = async (markdown, opts = {}) => {
         const state = {
             options,
             tokens: [],
@@ -76,7 +78,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 +94,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 +123,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],
             };
@@ -137,6 +146,7 @@ export function createParse(options = {}) {
         }
         return state.tree;
     };
+    return parseFn;
 }
 /**
  * Parse Comark content from a string

package/dist/plugins/alert.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("comark").ComarkPluginFactory<unknown>;
+declare const _default: import("comark").ComarkPluginFactory<unknown, {}, {}>;
 export default _default;

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.d.ts

@@ -7,7 +7,7 @@ export interface MdcInlineBindingOptions {
      */
     tag?: string;
 }
-declare const _default: import("../types").ComarkPluginFactory<MdcInlineBindingOptions>;
+declare const _default: import("../types").ComarkPluginFactory<MdcInlineBindingOptions, {}, {}>;
 export default _default;
 /**
  * Markdown-format handler that renders a `binding` node back to the

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.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("../types.ts").ComarkPluginFactory<unknown>;
+declare const _default: import("../types.ts").ComarkPluginFactory<unknown, {}, {}>;
 export default _default;

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.d.ts

@@ -1,4 +1,4 @@
 import type { MarkdownItPlugin } from 'comark';
 export declare const markdownItEmoji: MarkdownItPlugin;
-declare const _default: import("comark").ComarkPluginFactory<unknown>;
+declare const _default: import("comark").ComarkPluginFactory<unknown, {}, {}>;
 export default _default;

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.d.ts

@@ -35,7 +35,7 @@ export interface FootnotesConfig {
  * })
  * ```
  */
-declare const _default: import("comark").ComarkPluginFactory<FootnotesConfig>;
+declare const _default: import("comark").ComarkPluginFactory<FootnotesConfig, {}, {}>;
 export default _default;
 /**
  * Conditional stringify handler for footnotes.

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.d.ts

@@ -1,15 +1,17 @@
 export interface HeadingsOptions {
     /**
      * Tag to extract as title and set to `tree.meta.title`.
+     * Set to `false` to disable title extraction.
      * @default 'h1'
      */
-    titleTag?: string;
+    titleTag?: string | false;
     /**
      * Tag to extract as description and set to `tree.meta.description`.
      * Useful alternatives: `'blockquote'`
+     * Set to `false` to disable description extraction.
      * @default 'p'
      */
-    descriptionTag?: string;
+    descriptionTag?: string | false;
     /**
      * Whether to remove the extracted nodes from the tree.
      * @default false
@@ -29,20 +31,29 @@ export interface HeadingsOptions {
  *    content is written to `tree.meta.description`. When no title was found,
  *    this check starts from the very first content node.
  *
- * Both nodes are removed from the tree by default so they are not rendered
- * twice. Set `remove: false` to keep them in place.
+ * By default the extracted nodes are kept in the tree. Set `remove: true`
+ * to strip them so they are not rendered twice.
  *
  * @example
  * ```ts
- * // Default — h1 as title, first paragraph as description
+ * // Default — h1 as title, first paragraph as description, nodes kept in tree
  * headings()
  *
  * // Use a blockquote as the description instead of a paragraph
  * headings({ descriptionTag: 'blockquote' })
  *
- * // Extract metadata without removing the nodes from the tree
- * headings({ remove: false })
+ * // Extract metadata and remove the matched nodes from the tree
+ * headings({ remove: true })
+ *
+ * // Disable title extraction, only extract description
+ * headings({ titleTag: false })
+ *
+ * // Disable description extraction, only extract title
+ * headings({ descriptionTag: false })
  * ```
  */
-declare const _default: import("comark").ComarkPluginFactory<HeadingsOptions>;
+declare const _default: import("comark").ComarkPluginFactory<HeadingsOptions, {
+    title?: string;
+    description?: string;
+}, {}>;
 export default _default;