comark 0.3.2 → 0.5.0

package/dist/parse.js

@@ -44,13 +44,16 @@ 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,
+        linkify: options.linkify ?? true,
     }).enable(['table', 'strikethrough']);
     if (options.html !== false) {
         parser.inline.ruler.before('text', 'comark_html_inline', html_inline);
@@ -65,7 +68,7 @@ export function createParse(options = {}) {
     }
     let lastOutput = null;
     let lastInput = null;
-    return async (markdown, opts = {}) => {
+    const parseFn = async (markdown, opts = {}) => {
         const state = {
             options,
             tokens: [],
@@ -143,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/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/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/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/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/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;

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 = {}) => {
@@ -60,17 +66,21 @@ export default defineComarkPlugin((options = {}) => {
             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

package/dist/plugins/highlight.d.ts

@@ -56,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

@@ -278,10 +278,12 @@ export async function highlightCodeBlocks(tree, options = {}) {
                 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: classStr,
-            tabindex: '0',
+            class: userClass ? `${classStr} . ${userClass}` : classStr,
         };
         if (options.preStyles) {
             const lightTheme = options.themes?.light;

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

package/dist/plugins/punctuation.d.ts

@@ -63,5 +63,5 @@ export interface PunctuationOptions {
  * })
  * ```
  */
-declare const _default: import("comark").ComarkPluginFactory<PunctuationOptions>;
+declare const _default: import("comark").ComarkPluginFactory<PunctuationOptions, {}, {}>;
 export default _default;

package/dist/plugins/security.d.ts

@@ -1,3 +1,4 @@
+import type { ComarkElement, ComarkNode } from 'comark';
 import type { PropsValidationOptions } from '../internal/props-validation.ts';
 interface SecurityOptions extends PropsValidationOptions {
     /**
@@ -5,6 +6,16 @@ interface SecurityOptions extends PropsValidationOptions {
      * @default []
      */
     blockedTags?: string[];
+    /**
+     * Tags to allow only in the output tree.
+     * @default []
+     */
+    allowedTags?: string[];
+    /**
+     * Behavior when encountering an unallowed or blocked tag.
+     * @default undefined
+     */
+    tagFallback?: (element: ComarkElement) => false | ComarkNode | Promise<false | ComarkNode>;
 }
-declare const _default: import("comark").ComarkPluginFactory<SecurityOptions>;
+declare const _default: import("comark").ComarkPluginFactory<SecurityOptions, {}, {}>;
 export default _default;

package/dist/plugins/security.js

@@ -1,9 +1,10 @@
 import { defineComarkPlugin } from "../utils/helpers.js";
-import { visit } from "../utils/index.js";
+import { visitAsync } from "../utils/index.js";
 import { validateProps } from "../internal/props-validation.js";
 export default defineComarkPlugin((options = {}) => {
-    const { blockedTags = [], allowedLinkPrefixes, allowedImagePrefixes, allowedProtocols, defaultOrigin, allowDataImages, } = options;
+    const { blockedTags = [], allowedTags = [], tagFallback = undefined, allowedLinkPrefixes, allowedImagePrefixes, allowedProtocols, defaultOrigin, allowDataImages, } = options;
     const dropSet = new Set(blockedTags.map((t) => t.toLowerCase()));
+    const allowSet = new Set(allowedTags.map((t) => t.toLowerCase()));
     const propsOptions = {
         allowedLinkPrefixes,
         allowedImagePrefixes,
@@ -13,11 +14,17 @@ export default defineComarkPlugin((options = {}) => {
     };
     return {
         name: 'security',
-        post(state) {
-            visit(state.tree, (node) => typeof node !== 'string' && node[0] !== null, (node) => {
+        async post(state) {
+            await visitAsync(state.tree, (node) => typeof node !== 'string' && node[0] !== null, async (node) => {
                 const element = node;
-                // return false to remove the node from the tree
-                if (dropSet.has(element[0].toLowerCase())) {
+                const tagName = element[0].toLowerCase();
+                const isBlocked = dropSet.has(tagName);
+                const isNotAllowed = allowSet.size > 0 && !allowSet.has(tagName);
+                if (isNotAllowed || isBlocked) {
+                    if (typeof tagFallback === 'function') {
+                        return await tagFallback(element);
+                    }
+                    // return false to remove the node from the tree
                     return false;
                 }
                 const keys = Object.keys(element[1]);

package/dist/plugins/summary.d.ts

@@ -1,4 +1,7 @@
+import type { ComarkNode } from 'comark';
 declare const _default: import("comark").ComarkPluginFactory<{
     delimiter?: string;
-}>;
+}, {
+    summary: ComarkNode[];
+}, {}>;
 export default _default;

package/dist/plugins/syntax.d.ts

@@ -44,6 +44,6 @@ export interface SyntaxOptions {
      */
     bindingTag?: string;
 }
-declare const _default: import("../types.ts").ComarkPluginFactory<SyntaxOptions>;
+declare const _default: import("../types.ts").ComarkPluginFactory<SyntaxOptions, {}, {}>;
 export default _default;
 export declare const markdownItComark: MarkdownItPluginWithOptions<SyntaxOptions>;

package/dist/plugins/syntax.js

@@ -4,6 +4,22 @@ 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";
+/**
+ * A component name must start with a letter or `$`, followed by word chars,
+ * `$` or `-`. Mirrors the block name grammar (`RE_BLOCK_NAME = /^[a-z$]/i`).
+ */
+const RE_COMPONENT_NAME = /^[a-z$][\w$-]*/i;
+/**
+ * Whether `name` begins with a syntactically valid component name.
+ *
+ * This prevents sequences such as `:8100` or `::30` from being treated as
+ * components — a purely numeric name is not a valid component and would
+ * otherwise produce invalid output like `createElement('8100')` (inline) or
+ * throw `Invalid block params` (block).
+ */
+function isValidComponentName(name) {
+    return RE_COMPONENT_NAME.test(name);
+}
 // #region Block component plugin (`::name` and `::name ... ::`)
 const blockYamlLines = {
     '---': '---',
@@ -18,7 +34,7 @@ const markdownItComarkBlock = (md) => {
     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))
+        if (line[0] !== ':' || !isValidComponentName(line.slice(1)))
             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
@@ -78,6 +94,11 @@ const markdownItComarkBlock = (md) => {
         if (marker_count < min_markers)
             return false;
         const markup = state.src.slice(start, pos);
+        // Bail out (plain text) on an invalid name instead of letting
+        // parseBlockParams throw on e.g. `::8100`.
+        const nameStart = state.skipSpaces(pos);
+        if (nameStart < max && !isValidComponentName(state.src.slice(nameStart, max)))
+            return false;
         const params = parseBlockParams(state.src.slice(pos, max));
         if (!params.name)
             return false;
@@ -201,6 +222,12 @@ const markdownItComarkBlock = (md) => {
         const blockAttributesClosingFence = blockYamlLines[line] || '';
         if (!blockAttributesClosingFence)
             return false;
+        // The `---` fence is only valid on the line immediately after the component opener. Any other `---` is a thematic break.
+        if (line === '---') {
+            const parentOpenLine = state.env.comarkBlockTokens[0].map?.[0];
+            if (parentOpenLine === undefined || startLine !== parentOpenLine + 1)
+                return false;
+        }
         let lineEnd = startLine + 1;
         let found = false;
         while (lineEnd < endLine) {
@@ -237,8 +264,38 @@ const markdownItComarkBlock = (md) => {
         const line = state.src.slice(start, state.eMarks[startLine]);
         const { name, props } = parseBlockParams(line.slice(1));
         let lineEnd = startLine + 1;
+        let inCodeFence = false;
+        let codeFenceChar = '';
+        let codeFenceCount = 0;
         while (lineEnd < endLine) {
             const inner = state.src.slice(state.bMarks[lineEnd] + state.tShift[startLine], state.eMarks[lineEnd]);
+            if (inCodeFence) {
+                // Look for matching closing fence (same char, >= opening count, nothing but spaces after)
+                if (inner[0] === codeFenceChar) {
+                    let fencePos = 1;
+                    while (fencePos < inner.length && inner[fencePos] === codeFenceChar)
+                        fencePos++;
+                    if (fencePos >= codeFenceCount && inner.slice(fencePos).trim() === '') {
+                        inCodeFence = false;
+                    }
+                }
+                lineEnd += 1;
+                continue;
+            }
+            // Detect opening code fence (``` or ~~~, length >= 3)
+            if (inner[0] === '`' || inner[0] === '~') {
+                const ch = inner[0];
+                let fencePos = 1;
+                while (fencePos < inner.length && inner[fencePos] === ch)
+                    fencePos++;
+                if (fencePos >= 3) {
+                    inCodeFence = true;
+                    codeFenceChar = ch;
+                    codeFenceCount = fencePos;
+                    lineEnd += 1;
+                    continue;
+                }
+            }
             if (/^#\w+/.test(inner) || inner.startsWith('::'))
                 break;
             lineEnd += 1;
@@ -347,10 +404,12 @@ const markdownItInlineComponent = (md) => {
         // Empty name
         if (nameEnd <= start + 1)
             return false;
+        const name = state.src.slice(start + 1, nameEnd);
+        if (!isValidComponentName(name))
+            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;
@@ -397,52 +456,52 @@ const markdownItInlineProps = (md) => {
     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`
+        // When the trailing inline child is a props token directly after a text
+        // node, lift the props onto the surrounding heading/paragraph/list_item.
+        // (If the props follow a closing tag, they belong to that inline tag, not
+        // the parent — leave them alone.)
         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
+            // Tight-list paragraph: the inline lives one slot ahead
             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')
+            if (token.type !== 'inline' || !token.children?.length)
                 return;
-            const prev = tokens[index - 1];
-            if (!prev || prev.type !== 'mdc_block_open' || prev.tag !== 'ul')
+            const last = token.children[token.children.length - 1];
+            if (last.type !== 'mdc_inline_props')
                 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;
+            // Find the previous non-empty child. Markdown-it's emphasis tokenizer
+            // can leave an empty text token between the closing delimiter and the
+            // props — skipping it lets us distinguish "props on the parent" from
+            // "props on the preceding inline tag".
+            let beforeIdx = token.children.length - 2;
+            while (beforeIdx >= 0) {
+                const child = token.children[beforeIdx];
+                if (child.type === 'text' && !child.content) {
+                    beforeIdx--;
+                    continue;
+                }
+                break;
             }
-            const tokenClose = tokens[closeIndex];
-            if (tokenClose?.type !== 'bullet_list_close')
+            const beforeProps = beforeIdx >= 0 ? token.children[beforeIdx] : undefined;
+            if (!beforeProps || beforeProps.type !== 'text')
                 return;
-            const next = tokens[closeIndex + 1];
-            if (next?.type === 'mdc_block_close' && next.tag === 'ul') {
-                tokenOpen.hidden = true;
-                tokenClose.hidden = true;
+            // Strip the trailing space the text picked up before the `{...}` token.
+            if (typeof beforeProps.content === 'string') {
+                beforeProps.content = beforeProps.content.replace(/[ \t]+$/, '');
             }
+            const props = last.attrs;
+            // Drop the props token (last) plus any empty text tokens it left behind.
+            token.children.length = beforeProps.content ? beforeIdx + 1 : beforeIdx;
+            props?.forEach(([key, value]) => {
+                if (key === 'class')
+                    prev.attrJoin('class', value);
+                else
+                    prev.attrSet(key, value);
+            });
         });
         return tokens;
     };

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

@@ -4,5 +4,5 @@
  * This plugin runs before inline parsing to prevent Comark from interpreting
  * task list markers [X] and [ ] as Comark inline span syntax.
  */
-declare const _default: import("../types.ts").ComarkPluginFactory<unknown>;
+declare const _default: import("../types.ts").ComarkPluginFactory<unknown, {}, {}>;
 export default _default;

package/dist/plugins/toc.d.ts

@@ -12,5 +12,7 @@ export interface Toc {
     links: TocLink[];
 }
 export declare function generateFlatToc(body: ComarkTree, options: Toc): Toc;
-declare const _default: import("comark").ComarkPluginFactory<Partial<Toc>>;
+declare const _default: import("comark").ComarkPluginFactory<Partial<Toc>, {
+    toc: Toc;
+}, {}>;
 export default _default;

package/dist/render.d.ts

@@ -8,7 +8,9 @@ export { resolveAttributes, resolveAttribute } from './internal/stringify/attrib
  * @param context - The context of the renderer
  * @returns The string representation of the Comark tree
  */
-export declare function render(tree: ComarkTree, context?: RenderOptions): Promise<string>;
+export declare function render(tree: ComarkTree | {
+    nodes: ComarkTree['nodes'];
+}, context?: RenderOptions): Promise<string>;
 /**
  * Render Comark tree to markdown
  *
@@ -16,4 +18,6 @@ export declare function render(tree: ComarkTree, context?: RenderOptions): Promi
  * @param options - Optional rendering options
  * @returns The markdown string with optional frontmatter
  */
-export declare function renderMarkdown(tree: ComarkTree, options?: RenderMarkdownOptions): Promise<string>;
+export declare function renderMarkdown(tree: ComarkTree | {
+    nodes: ComarkTree['nodes'];
+}, options?: RenderMarkdownOptions): Promise<string>;

package/dist/render.js

@@ -11,7 +11,7 @@ export { resolveAttributes, resolveAttribute } from "./internal/stringify/attrib
  * @returns The string representation of the Comark tree
  */
 export async function render(tree, context = {}) {
-    const state = createState({ ...context, tree, handlers: context.components });
+    const state = createState({ ...context, tree: tree, handlers: context.components });
     let result = '';
     for (const child of tree.nodes) {
         result += await one(child, state);
@@ -27,5 +27,5 @@ export async function render(tree, context = {}) {
  */
 export async function renderMarkdown(tree, options) {
     const content = await render(tree, { format: 'markdown/comark', ...options });
-    return renderFrontmatter(tree.frontmatter, content, options?.frontmatterOptions);
+    return renderFrontmatter(tree.frontmatter || {}, content, options?.frontmatterOptions);
 }