comark 0.3.1 → 0.3.2

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,159 @@ 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;
             }
         }
         const newPreAttrs = {
             ...preAttrs,
-            class: [...preNodeClasses, options.themes?.dark?.name ? `dark:${options.themes?.dark?.name}` : ''].filter(Boolean).join(' '),
+            class: classStr,
             tabindex: '0',
         };
         if (options.preStyles) {
@@ -222,14 +305,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.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.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.js

@@ -43,7 +43,7 @@ export function searchProps(content, index = 0) {
         '(': ')',
     };
     const quotePairs = {
-        '\'': '\'',
+        "'": "'",
         '"': '"',
         '`': '`',
     };
@@ -67,17 +67,11 @@ export function searchProps(content, index = 0) {
         }
         else if (content[index] === '.') {
             index += 1;
-            props.push([
-                'class',
-                searchUntil(' #.}'),
-            ]);
+            props.push(['class', searchUntil(' #.}')]);
         }
         else if (content[index] === '#') {
             index += 1;
-            props.push([
-                'id',
-                searchUntil(' #.}'),
-            ]);
+            props.push(['id', searchUntil(' #.}')]);
         }
         else {
             const start = index;
@@ -91,16 +85,10 @@ export function searchProps(content, index = 0) {
                 const key = content.slice(start, index).trim();
                 if (char === '=') {
                     index += 1;
-                    props.push([
-                        key,
-                        searchValue(),
-                    ]);
+                    props.push([key, searchValue()]);
                 }
                 else {
-                    props.push([
-                        key,
-                        'true',
-                    ]);
+                    props.push([key, 'true']);
                 }
             }
         }
@@ -178,7 +166,5 @@ export function searchProps(content, index = 0) {
  */
 export default defineComarkPlugin((config = {}) => ({
     name: 'mermaid',
-    markdownItPlugins: [
-        ((md) => markdownItMermaid(md, config)),
-    ],
+    markdownItPlugins: [((md) => markdownItMermaid(md, config))],
 }));

package/dist/plugins/punctuation.js

@@ -3,8 +3,7 @@ const DEFAULT_QUOTES = '\u201C\u201D\u2018\u2019'; // ""''
 /** Tags whose text content should not be transformed */
 const SKIP_TAGS = new Set(['code', 'pre', 'math', 'script', 'style', 'kbd']);
 function isWhitespaceOrOpener(ch) {
-    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r'
-        || ch === '(' || ch === '[' || ch === '{';
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r' || ch === '(' || ch === '[' || ch === '{';
 }
 function isLetter(ch) {
     return (ch >= 'a' && ch <= 'z') || (ch >= 'A' && ch <= 'Z');
@@ -117,11 +116,11 @@ function applyPunctuation(text, enableQuotes, dashes, ellipsis, symbols, normali
         if (enableQuotes) {
             if (ch === '"') {
                 const prev = i > 0 ? text[i - 1] : ' ';
-                result += text.slice(last, i) + ((isWhitespaceOrOpener(prev) || i === 0) ? openDouble : closeDouble);
+                result += text.slice(last, i) + (isWhitespaceOrOpener(prev) || i === 0 ? openDouble : closeDouble);
                 last = i + 1;
                 continue;
             }
-            if (ch === '\'') {
+            if (ch === "'") {
                 const prev = i > 0 ? text[i - 1] : ' ';
                 const next = i + 1 < len ? text[i + 1] : '';
                 result += text.slice(last, i);
@@ -130,7 +129,7 @@ function applyPunctuation(text, enableQuotes, dashes, ellipsis, symbols, normali
                     result += closeSingle;
                 }
                 else {
-                    result += (isWhitespaceOrOpener(prev) || i === 0) ? openSingle : closeSingle;
+                    result += isWhitespaceOrOpener(prev) || i === 0 ? openSingle : closeSingle;
                 }
                 last = i + 1;
                 continue;
@@ -181,7 +180,7 @@ function applyPunctuation(text, enableQuotes, dashes, ellipsis, symbols, normali
  * ```
  */
 export default defineComarkPlugin((options = {}) => {
-    const { quotes = true, dashes = true, ellipsis = true, symbols = true, normalize = true, } = options;
+    const { quotes = true, dashes = true, ellipsis = true, symbols = true, normalize = true } = options;
     // Resolve quote characters
     let enableQuotes;
     let openDouble;

package/dist/plugins/security.js

@@ -3,7 +3,7 @@ import { visit } from "../utils/index.js";
 import { validateProps } from "../internal/props-validation.js";
 export default defineComarkPlugin((options = {}) => {
     const { blockedTags = [], allowedLinkPrefixes, allowedImagePrefixes, allowedProtocols, defaultOrigin, allowDataImages, } = options;
-    const dropSet = new Set(blockedTags.map(t => t.toLowerCase()));
+    const dropSet = new Set(blockedTags.map((t) => t.toLowerCase()));
     const propsOptions = {
         allowedLinkPrefixes,
         allowedImagePrefixes,
@@ -14,7 +14,7 @@ export default defineComarkPlugin((options = {}) => {
     return {
         name: 'security',
         post(state) {
-            visit(state.tree, node => typeof node !== 'string' && node[0] !== null, (node) => {
+            visit(state.tree, (node) => typeof node !== 'string' && node[0] !== null, (node) => {
                 const element = node;
                 // return false to remove the node from the tree
                 if (dropSet.has(element[0].toLowerCase())) {

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