comark 0.3.1 → 0.4.0

package/dist/plugins/headings.js

@@ -35,19 +35,25 @@ function flattenNodeText(node) {
  *    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 })
  * ```
  */
 export default defineComarkPlugin((options = {}) => {
@@ -57,26 +63,28 @@ 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];
-            if (first && getTag(first) === titleTag) {
-                titleNodeIndex = nodes.indexOf(first);
-                state.tree.meta.title = flattenNodeText(first);
+            let nextContentIndex = 0;
+            if (titleTag !== false) {
+                const first = contentNodes[0];
+                if (first && getTag(first) === titleTag) {
+                    titleNodeIndex = nodes.indexOf(first);
+                    state.tree.meta.title = flattenNodeText(first);
+                    nextContentIndex = 1;
+                }
             }
-            // Description is the first content node after the (optional) title
-            const afterTitle = titleNodeIndex !== -1 ? contentNodes.slice(1) : contentNodes;
-            const second = afterTitle[0];
-            if (second && getTag(second) === descriptionTag) {
-                descriptionNodeIndex = nodes.indexOf(second);
-                state.tree.meta.description = flattenNodeText(second);
+            if (descriptionTag !== false) {
+                const candidate = contentNodes[nextContentIndex];
+                if (candidate && getTag(candidate) === descriptionTag) {
+                    descriptionNodeIndex = nodes.indexOf(candidate);
+                    state.tree.meta.description = flattenNodeText(candidate);
+                }
             }
             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
@@ -66,5 +56,5 @@ export declare function highlightCodeBlocks(tree: ComarkTree, options?: Highligh
  * Useful for testing or when you want to reconfigure
  */
 export declare function resetHighlighter(): void;
-declare const _default: import("comark").ComarkPluginFactory<HighlightOptions>;
+declare const _default: import("comark").ComarkPluginFactory<HighlightOptions, {}, {}>;
 export default _default;

package/dist/plugins/highlight.js

@@ -1,7 +1,8 @@
 import { defineComarkPlugin } from "../utils/helpers.js";
 import { createShikiPrimitive } from 'shiki';
 import { createJavaScriptRegexEngine } from 'shiki/engine/javascript';
-import { codeToHast } from 'shiki/core';
+import { codeToHast, codeToTokens, getTokenStyleObject, stringifyTokenStyle } from 'shiki/core';
+import comakLanguage from "../utils/comark.tmLanguage.js";
 let highlighter = null;
 let highlighterPromise = null;
 const loadedThemes = new Set();
@@ -11,11 +12,14 @@ const loadedLanguages = new Set();
  * Uses a singleton pattern to avoid creating multiple highlighters
  */
 export async function getHighlighter(options = {}) {
-    // If highlighter exists, load any new themes that aren't loaded yet
     if (highlighter) {
+        // Fast path: skip registerDefaults() when no custom themes/languages are requested
+        if (!options.themes && !options.languages) {
+            return highlighter;
+        }
         const { themes, languages } = await registerDefaults(options);
-        await Promise.all(themes.map(theme => loadTheme(highlighter, theme)));
-        await Promise.all(languages.map(language => loadLanguage(highlighter, language)));
+        await Promise.all(themes.map((theme) => loadTheme(highlighter, theme)));
+        await Promise.all(languages.map((language) => loadLanguage(highlighter, language)));
         return highlighter;
     }
     if (highlighterPromise) {
@@ -28,16 +32,16 @@ export async function getHighlighter(options = {}) {
                 themes: themes,
                 langs: languages,
                 langAlias: {
-                    'md': 'mdc',
-                    'markdown': 'mdc',
-                    'comark': 'mdc',
+                    md: 'mdc',
+                    markdown: 'mdc',
+                    comark: 'mdc',
                     'json-render': 'json',
                     'yaml-render': 'yaml',
                 },
                 engine: createJavaScriptRegexEngine({ forgiving: true }),
             });
-            await Promise.all(themes.map(theme => loadTheme(hl, theme)));
-            await Promise.all(languages.map(language => loadLanguage(hl, language)));
+            await Promise.all(themes.map((theme) => loadTheme(hl, theme)));
+            await Promise.all(languages.map((language) => loadLanguage(hl, language)));
             return hl;
         })();
         highlighter = await highlighterPromise;
@@ -54,10 +58,18 @@ async function registerDefaults(options) {
     const languages = options.languages || [];
     const promises = [];
     if (options.registerDefaultThemes !== false) {
-        promises.push(import('shiki/dist/themes/material-theme-lighter.mjs').then(m => ({ type: 'theme', value: m.default })), import('shiki/dist/themes/material-theme-palenight.mjs').then(m => ({ type: 'theme', value: m.default })));
+        promises.push(import('shiki/dist/themes/material-theme-lighter.mjs').then((m) => ({
+            type: 'theme',
+            value: m.default,
+        })), import('shiki/dist/themes/material-theme-palenight.mjs').then((m) => ({
+            type: 'theme',
+            value: m.default,
+        })));
     }
     if (options.registerDefaultLanguages !== false) {
-        promises.push(import('shiki/dist/langs/vue.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/tsx.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/svelte.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/typescript.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/javascript.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/mdc.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/bash.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/json.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/yaml.mjs').then(m => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/astro.mjs').then(m => ({ type: 'lang', value: m.default })));
+        promises.push(import('shiki/dist/langs/vue.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/tsx.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/svelte.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/typescript.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/javascript.mjs').then((m) => ({ type: 'lang', value: m.default })), 
+        // import('shiki/dist/langs/mdc.mjs').then(m => ({ type: 'lang' as const, value: m.default })),
+        import('shiki/dist/langs/bash.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/json.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/yaml.mjs').then((m) => ({ type: 'lang', value: m.default })), import('shiki/dist/langs/astro.mjs').then((m) => ({ type: 'lang', value: m.default })));
     }
     const results = await Promise.all(promises);
     for (const result of results) {
@@ -66,6 +78,8 @@ async function registerDefaults(options) {
         else
             languages.push(result.value);
     }
+    // Remove custom language after updating language in shiki core
+    languages.push(comakLanguage);
     return { themes, languages };
 }
 async function loadTheme(hl, theme) {
@@ -76,64 +90,37 @@ async function loadTheme(hl, theme) {
     loadedThemes.add(theme.name || '');
 }
 async function loadLanguage(hl, language) {
-    if (loadedLanguages.has(Array.isArray(language) ? language.map(l => l.name || '').join(',') : language.name || '')) {
+    if (loadedLanguages.has(Array.isArray(language) ? language.map((l) => l.name || '').join(',') : language.name || '')) {
         return;
     }
     await hl.loadLanguage(language);
-    loadedLanguages.add(Array.isArray(language) ? language.map(l => l.name || '').join(',') : language.name || '');
+    loadedLanguages.add(Array.isArray(language) ? language.map((l) => l.name || '').join(',') : language.name || '');
 }
 /**
- * Highlight code using Shiki with codeToTokens
- * Returns comark nodes built from hast
+ * Convert a hast (HTML AST) node into a ComarkNode.
+ * Uses pre-allocated arrays to avoid spread overhead.
  */
-export async function highlightCode(code, attrs, options = {}) {
-    // Extract language from attributes
-    const language = attrs?.language;
-    try {
-        const hl = await getHighlighter(options);
-        const { themes = { light: 'material-theme-lighter', dark: 'material-theme-palenight' } } = options;
-        const lightTheme = themes.light || themes.dark || 'material-theme-lighter';
-        const darkTheme = themes.dark || themes.light || 'material-theme-palenight';
-        // Use codeToTokens to get raw tokens
-        const result = await codeToHast(hl, code, {
-            lang: language,
-            transformers: options.transformers,
-            themes: {
-                light: lightTheme,
-                dark: lightTheme !== darkTheme ? darkTheme : undefined,
-            },
-            meta: {
-                __raw: attrs.meta,
-            },
-        });
-        const allTokens = result.children.map(hastToMinimarkNode);
-        return {
-            nodes: allTokens,
-            language,
-        };
-    }
-    catch (error) {
-        // If highlighting fails, return the original code
-        console.error('Shiki highlighting error:', error);
-        return {
-            nodes: [code],
-            language,
-        };
+function hastToComarkNode(input) {
+    if (input.type === 'text')
+        return input.value;
+    if (input.type === 'comment')
+        return [null, {}, input.value];
+    const props = input.properties || {};
+    if (input.tag === 'code' && props?.className && props.className.length === 0) {
+        delete props.className;
     }
-    function hastToMinimarkNode(input) {
-        const props = input.properties || {};
-        if (input.type === 'comment')
-            return [null, {}, input.value];
-        if (input.type === 'text')
-            return input.value;
-        if (input.tag === 'code' && props?.className && props.className.length === 0)
-            delete props.className;
-        return [
-            input.tagName,
-            props,
-            ...(input.children || []).map(hastToMinimarkNode),
-        ];
+    const children = input.children;
+    if (!children || children.length === 0)
+        return [input.tagName, props];
+    const len = children.length;
+    // eslint-disable-next-line unicorn/no-new-array -- pre-allocated for perf
+    const result = new Array(len + 2);
+    result[0] = input.tagName;
+    result[1] = props;
+    for (let i = 0; i < len; i++) {
+        result[i + 2] = hastToComarkNode(children[i]);
     }
+    return result;
 }
 /**
  * Apply syntax highlighting to all code blocks in a Comark tree
@@ -141,63 +128,162 @@ export async function highlightCode(code, attrs, options = {}) {
  */
 export async function highlightCodeBlocks(tree, options = {}) {
     const codeBlocks = [];
-    const findCodeBlocks = (nodes, path) => {
-        for (let i = 0; i < nodes.length; i++) {
-            const node = nodes[i];
-            if (typeof node === 'string')
+    const pathBuf = [];
+    // Recursively find <pre><code> blocks, tracking their path via push/pop on a shared buffer
+    const walkChildren = (element) => {
+        for (let i = 2; i < element.length; i++) {
+            const child = element[i];
+            if (typeof child === 'string')
                 continue;
-            if (!Array.isArray(node) || node.length < 3)
+            if (!Array.isArray(child) || child.length < 3)
                 continue;
-            if (node[0] === 'pre' && Array.isArray(node[2]) && node[2][0] === 'code') {
-                const codeContent = node[2][2];
+            pathBuf.push(i - 2);
+            if (child[0] === 'pre' && Array.isArray(child[2]) && child[2][0] === 'code') {
+                const codeContent = child[2][2];
                 if (typeof codeContent === 'string') {
-                    codeBlocks.push({ node, path: [...path, i] });
+                    codeBlocks.push({ node: child, path: pathBuf.slice() });
                 }
             }
-            findCodeBlocks(node.slice(2), [...path, i]);
+            walkChildren(child);
+            pathBuf.pop();
         }
     };
-    findCodeBlocks(tree.nodes, []);
+    for (let i = 0; i < tree.nodes.length; i++) {
+        const node = tree.nodes[i];
+        if (typeof node === 'string')
+            continue;
+        if (!Array.isArray(node) || node.length < 3)
+            continue;
+        if (node[0] === 'pre' && Array.isArray(node[2]) && node[2][0] === 'code') {
+            const codeContent = node[2][2];
+            if (typeof codeContent === 'string') {
+                codeBlocks.push({ node, path: [i] });
+            }
+        }
+        pathBuf.length = 1;
+        pathBuf[0] = i;
+        walkChildren(node);
+    }
     if (codeBlocks.length === 0)
         return tree;
-    const highlightedResults = await Promise.all(codeBlocks.map(({ node }) => {
-        return highlightCode(node[2][2], node[1], options);
-    }));
-    const newNodes = JSON.parse(JSON.stringify(tree.nodes));
+    const hl = await getHighlighter(options);
+    const { themes = { light: 'material-theme-lighter', dark: 'material-theme-palenight' } } = options;
+    const lightTheme = themes.light || themes.dark || 'material-theme-lighter';
+    const darkTheme = themes.dark || themes.light || 'material-theme-palenight';
+    const themeOptions = {
+        light: lightTheme,
+        dark: lightTheme !== darkTheme ? darkTheme : undefined,
+    };
+    const hasTransformers = options.transformers && options.transformers.length > 0;
+    const darkClassSuffix = options.themes?.dark?.name ? ` dark:${options.themes.dark.name}` : '';
+    // Build new nodes array, spine-copying only paths to modified <pre> nodes
+    const newNodes = [...tree.nodes];
     for (let i = 0; i < codeBlocks.length; i++) {
         const { node, path } = codeBlocks[i];
-        const preAttrs = node[1];
-        const result = highlightedResults[i];
-        const preNode = result.nodes[0];
-        const preNodeClasses = typeof preNode === 'string'
-            ? ['shiki', options.themes?.light?.name]
-            : (Array.isArray(preNode[1].class)
-                ? preNode[1].class
-                : String(preNode[1].class).split(' '));
-        const codeChildren = preNode[2].slice(2);
-        const children = typeof preNode === 'string'
-            ? preNode
-            : codeChildren;
-        if (Array.isArray(children)) {
-            let line = 1;
-            for (const child of children) {
-                if (Array.isArray(child)) {
-                    if (Array.isArray(preAttrs.highlights) && preAttrs.highlights.includes(line)) {
-                        child[1].class = `${child[1].class ?? ''} highlight`.trim();
-                        // TODO: (enforcing default style) once we unify all ecosystem styles we can remove this
-                        child[1].style = 'display: inline-block';
+        const code = node[2][2];
+        const attrs = node[1];
+        const preAttrs = attrs;
+        const language = attrs?.language;
+        let classStr;
+        let codeChildren;
+        try {
+            if (hasTransformers) {
+                // Transformers operate on hast, so we must go through codeToHast
+                const result = codeToHast(hl, code, {
+                    lang: language,
+                    transformers: options.transformers,
+                    themes: themeOptions,
+                    meta: { __raw: attrs.meta },
+                });
+                const preNode = result.children.map(hastToComarkNode)[0];
+                const cls = preNode[1].class;
+                classStr = Array.isArray(cls) ? cls.join(' ') : String(cls);
+                codeChildren = preNode[2].slice(2);
+            }
+            else {
+                // Fast path: build ComarkNodes directly from tokens, skipping hast
+                const result = codeToTokens(hl, code, {
+                    lang: language,
+                    themes: themeOptions,
+                });
+                classStr = `shiki ${result.themeName || ''}`;
+                // Replicate shiki's mergeWhitespaceTokens: merge pure-whitespace tokens
+                // into the following token (unless underline/strikethrough styled)
+                const tokenLines = result.tokens;
+                codeChildren = [];
+                for (let li = 0; li < tokenLines.length; li++) {
+                    const line = tokenLines[li];
+                    const spanCount = line.length;
+                    // Merge whitespace tokens inline while building spans
+                    let carry = '';
+                    const spans = [];
+                    for (let t = 0; t < spanCount; t++) {
+                        const tk = line[t];
+                        const canMerge = !((tk.fontStyle && (tk.fontStyle & 8 /* Strikethrough */ || tk.fontStyle & 4)) /* Underline */);
+                        if (canMerge && /^\s+$/.test(tk.content) && t + 1 < spanCount) {
+                            carry += tk.content;
+                        }
+                        else if (carry) {
+                            const style = stringifyTokenStyle(tk.htmlStyle || getTokenStyleObject(tk));
+                            if (canMerge) {
+                                spans.push(style ? ['span', { style }, carry + tk.content] : ['span', {}, carry + tk.content]);
+                            }
+                            else {
+                                spans.push(['span', {}, carry]);
+                                spans.push(style ? ['span', { style }, tk.content] : ['span', {}, tk.content]);
+                            }
+                            carry = '';
+                        }
+                        else {
+                            const style = stringifyTokenStyle(tk.htmlStyle || getTokenStyleObject(tk));
+                            spans.push(style ? ['span', { style }, tk.content] : ['span', {}, tk.content]);
+                        }
                     }
-                    else {
-                        // TODO: (enforcing default style) once we unify all ecosystem styles we can remove this
-                        child[1].style = 'display: inline';
+                    // If trailing whitespace wasn't merged, emit it
+                    if (carry) {
+                        spans.push(['span', {}, carry]);
                     }
-                    line += 1;
+                    // eslint-disable-next-line unicorn/no-new-array -- pre-allocated for perf
+                    const lineNode = new Array(spans.length + 2);
+                    lineNode[0] = 'span';
+                    lineNode[1] = { class: 'line' };
+                    for (let s = 0; s < spans.length; s++)
+                        lineNode[s + 2] = spans[s];
+                    codeChildren.push(lineNode);
+                    if (li < tokenLines.length - 1)
+                        codeChildren.push('\n');
+                }
+            }
+        }
+        catch {
+            classStr = 'shiki';
+            codeChildren = [code];
+        }
+        if (darkClassSuffix)
+            classStr += darkClassSuffix;
+        // Apply line highlights
+        const highlightSet = Array.isArray(preAttrs.highlights) ? new Set(preAttrs.highlights) : null;
+        let line = 1;
+        for (const child of codeChildren) {
+            if (Array.isArray(child)) {
+                if (highlightSet !== null && highlightSet.has(line)) {
+                    child[1].class = `${child[1].class ?? ''} highlight`.trim();
+                    // TODO: (enforcing default style) once we unify all ecosystem styles we can remove this
+                    child[1].style = 'display: inline-block';
+                }
+                else {
+                    // TODO: (enforcing default style) once we unify all ecosystem styles we can remove this
+                    child[1].style = 'display: inline';
                 }
+                line += 1;
             }
         }
+        // Merge highlighter class with any user-supplied class (e.g. from
+        // `::pre{.user-class}`) so the wrapper's class isn't lost.
+        const userClass = typeof preAttrs.class === 'string' ? preAttrs.class.trim() : '';
         const newPreAttrs = {
             ...preAttrs,
-            class: [...preNodeClasses, options.themes?.dark?.name ? `dark:${options.themes?.dark?.name}` : ''].filter(Boolean).join(' '),
+            class: userClass ? `${classStr} . ${userClass}` : classStr,
             tabindex: '0',
         };
         if (options.preStyles) {
@@ -222,14 +308,26 @@ export async function highlightCodeBlocks(tree, options = {}) {
         }
         const codeEl = node[2];
         const codeAttrs = codeEl[1] || {};
-        const newPreNode = ['pre', newPreAttrs, ['code', codeAttrs, ...children]];
+        // eslint-disable-next-line unicorn/no-new-array -- pre-allocated for perf
+        const codeNode = new Array(codeChildren.length + 2);
+        codeNode[0] = 'code';
+        codeNode[1] = codeAttrs;
+        for (let j = 0; j < codeChildren.length; j++)
+            codeNode[j + 2] = codeChildren[j];
+        const newPreNode = ['pre', newPreAttrs, codeNode];
         if (path.length === 1) {
             newNodes[path[0]] = newPreNode;
         }
         else {
-            let current = newNodes[path[0]];
+            // Copy only the spine from root to this node to preserve immutability
+            const rootIdx = path[0];
+            let current = [...newNodes[rootIdx]];
+            newNodes[rootIdx] = current;
             for (let j = 1; j < path.length - 1; j++) {
-                current = current[path[j] + 2];
+                const childSlot = path[j] + 2;
+                const next = [...current[childSlot]];
+                current[childSlot] = next;
+                current = next;
             }
             const childSlot = path[path.length - 1] + 2;
             current[childSlot] = newPreNode;

package/dist/plugins/json-render.d.ts

@@ -49,5 +49,5 @@ interface JsonRenderConfig {
  * </template>
  * ```
  */
-declare const _default: import("../types").ComarkPluginFactory<JsonRenderConfig>;
+declare const _default: import("../types").ComarkPluginFactory<JsonRenderConfig, {}, {}>;
 export default _default;

package/dist/plugins/json-render.js

@@ -16,13 +16,8 @@ function jsonRenderElementToAst(element, elements) {
     if (element.type === 'Text') {
         return String(element.props.content);
     }
-    const children = element.children?.map(childName => elements[childName])
-        .filter(Boolean) || [];
-    return [
-        element.type,
-        element.props,
-        ...children.map(child => jsonRenderElementToAst(child, elements)),
-    ];
+    const children = element.children?.map((childName) => elements[childName]).filter(Boolean) || [];
+    return [element.type, element.props, ...children.map((child) => jsonRenderElementToAst(child, elements))];
 }
 /**
  * Plugin for rendering [JSON Render](https://json-render.dev/) specs as UI components.
@@ -76,8 +71,9 @@ function jsonRenderElementToAst(element, elements) {
 export default defineComarkPlugin((_config = {}) => ({
     name: 'json-render',
     post: async (state) => {
-        visit(state.tree, node => node[0] === 'pre' && (node[1].language === 'json-render'
-            || node[1].language === 'yaml-render'), (preNode) => {
+        visit(state.tree, (node) => node[0] === 'pre' &&
+            (node[1].language === 'json-render' ||
+                node[1].language === 'yaml-render'), (preNode) => {
             const language = preNode[1].language;
             try {
                 let spec = undefined;

package/dist/plugins/math.d.ts

@@ -55,5 +55,5 @@ export declare function validateMath(code: string): boolean;
  * })
  * ```
  */
-declare const _default: import("comark").ComarkPluginFactory<MathConfig>;
+declare const _default: import("comark").ComarkPluginFactory<MathConfig, {}, {}>;
 export default _default;

package/dist/plugins/math.js

@@ -70,7 +70,7 @@ function mathInlineDisplayRule(state, silent, _config) {
     let pos = start + 2;
     while (pos + 1 < max) {
         // Stop at newline
-        if (state.src.charCodeAt(pos) === 0x0A /* \n */) {
+        if (state.src.charCodeAt(pos) === 0x0a /* \n */) {
             return false;
         }
         // Check for $$
@@ -110,7 +110,7 @@ function mathInlineRule(state, silent, _config) {
     while (pos < max) {
         const char = state.src.charCodeAt(pos);
         // Stop at newline - $ must close on same line
-        if (char === 0x0A /* \n */) {
+        if (char === 0x0a /* \n */) {
             return false;
         }
         if (char === 0x24 /* $ */) {
@@ -119,7 +119,7 @@ function mathInlineRule(state, silent, _config) {
             // it's not preceded by another $ (which would make it $$),
             // and it's not followed by another $ (which would make it $$)
             const hasContent = pos > start + 1;
-            const notEscaped = pos === start + 1 || state.src.charCodeAt(pos - 1) !== 0x5C; /* \ */
+            const notEscaped = pos === start + 1 || state.src.charCodeAt(pos - 1) !== 0x5c; /* \ */
             const notPrecededByDollar = pos === start + 1 || state.src.charCodeAt(pos - 1) !== 0x24;
             const notFollowedByDollar = pos + 1 >= max || state.src.charCodeAt(pos + 1) !== 0x24;
             if (hasContent && notEscaped && notPrecededByDollar && notFollowedByDollar) {
@@ -256,7 +256,5 @@ function markdownItMath(md, config = {}) {
  */
 export default defineComarkPlugin((config = {}) => ({
     name: 'math',
-    markdownItPlugins: [
-        ((md) => markdownItMath(md, config)),
-    ],
+    markdownItPlugins: [((md) => markdownItMath(md, config))],
 }));

package/dist/plugins/mermaid.d.ts

@@ -34,5 +34,5 @@ export declare function searchProps(content: string, index?: number): {
  * })
  * ```
  */
-declare const _default: import("comark").ComarkPluginFactory<MermaidConfig>;
+declare const _default: import("comark").ComarkPluginFactory<MermaidConfig, {}, {}>;
 export default _default;