comark 0.0.1 → 0.1.0

package/dist/internal/props-validation.d.ts

@@ -0,0 +1,12 @@
+export declare const unsafeTags: string[];
+export declare const unsafeAttributes: string[];
+export declare const unsafeLinkPrefix: string[];
+export interface PropsValidationOptions {
+    allowedLinkPrefixes?: string[];
+    allowedImagePrefixes?: string[];
+    allowedProtocols?: string[];
+    defaultOrigin?: string;
+    allowDataImages?: boolean;
+}
+export declare function validateProp(attribute: string, value: string, options?: PropsValidationOptions): string | false;
+export declare function validateProps(type: string, props?: Record<string, any>, options?: PropsValidationOptions): Record<string, any>;

package/dist/internal/props-validation.js

@@ -0,0 +1,112 @@
+export const unsafeTags = [
+    'object',
+];
+export const unsafeAttributes = [
+    'srcdoc',
+    'formaction',
+];
+export const unsafeLinkPrefix = [
+    'javascript:',
+    'data:text/html',
+    'vbscript:',
+    'data:text/javascript',
+    'data:text/vbscript',
+    'data:text/css',
+    'data:text/plain',
+    'data:text/xml',
+];
+function rewriteToDefaultOrigin(urlStr, defaultOrigin) {
+    try {
+        const parsed = new URL(urlStr);
+        const origin = new URL(defaultOrigin);
+        parsed.protocol = origin.protocol;
+        parsed.host = origin.host;
+        return parsed.href;
+    }
+    catch {
+        return defaultOrigin;
+    }
+}
+function validateUrl(value, mode, options) {
+    const { allowedLinkPrefixes = ['*'], allowedImagePrefixes = ['*'], allowedProtocols = ['*'], defaultOrigin, allowDataImages = true, } = options;
+    const decodedUrl = decodeURIComponent(value);
+    const urlSanitized = decodedUrl
+        .replace(/&#x([0-9a-f]+);?/gi, '')
+        .replace(/&#(\d+);?/g, '')
+        .replace(/&[a-z]+;?/gi, '');
+    let url;
+    try {
+        // Parse without a base — throws for relative URLs, succeeds for absolute
+        url = new URL(urlSanitized);
+    }
+    catch {
+        // Relative URLs are always allowed
+        return value;
+    }
+    // Block known-unsafe protocols — hard floor, not overrideable by options
+    if (unsafeLinkPrefix.some(prefix => url.href.toLowerCase().startsWith(prefix))) {
+        return false;
+    }
+    // Block data: images when allowDataImages is false
+    if (mode === 'image' && !allowDataImages && url.protocol === 'data:') {
+        return false;
+    }
+    // Check allowed protocols
+    if (!allowedProtocols.includes('*')) {
+        const protocol = url.protocol.replace(':', '');
+        if (!allowedProtocols.includes(protocol)) {
+            return false;
+        }
+    }
+    // Check allowed URL prefixes
+    const allowedPrefixes = mode === 'link' ? allowedLinkPrefixes : allowedImagePrefixes;
+    if (!allowedPrefixes.includes('*')) {
+        const href = url.href.toLowerCase();
+        const matchesPrefix = allowedPrefixes.some(prefix => href.startsWith(prefix.toLowerCase()));
+        if (!matchesPrefix) {
+            if (defaultOrigin) {
+                return rewriteToDefaultOrigin(urlSanitized, defaultOrigin);
+            }
+            return false;
+        }
+    }
+    return value;
+}
+export function validateProp(attribute, value, options = {}) {
+    attribute = attribute.toLowerCase();
+    if (attribute.startsWith('on') || unsafeAttributes.includes(attribute)) {
+        return false;
+    }
+    if (attribute === 'href') {
+        return validateUrl(value, 'link', options);
+    }
+    if (attribute === 'src') {
+        return validateUrl(value, 'image', options);
+    }
+    return value;
+}
+export function validateProps(type, props, options = {}) {
+    /**
+     * If the tag is marked as unsafe, drop all props
+     */
+    if (unsafeTags.includes(type.toLowerCase())) {
+        return {};
+    }
+    if (!props)
+        return {};
+    const entries = Object.entries(props);
+    if (entries.length === 0)
+        return {};
+    props = Object.fromEntries(entries.flatMap(([name, value]) => {
+        if (name === 'id' && !value) {
+            return [];
+        }
+        const result = validateProp(name, value, options);
+        if (result === false) {
+            console.warn(`[comark/plugins/security] removing unsafe attribute: ${name}="${value}"`);
+            return [];
+        }
+        return [[name, result]];
+    }));
+    return props;
+}

package/dist/internal/stringify/attributes.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Convert attributes to a string of Comark attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export declare function comarkAttributes(attributes: Record<string, unknown>): string;
+/**
+ * Convert attributes to a string of HTML attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export declare function htmlAttributes(attributes: Record<string, unknown>): string;
+/**
+ * Convert attributes to a string of YAML attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export declare function comarkYamlAttributes(attributes: Record<string, unknown>): string;

package/dist/internal/stringify/attributes.js

@@ -0,0 +1,67 @@
+import { stringifyYaml } from "../yaml.js";
+/**
+ * Convert attributes to a string of Comark attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export function comarkAttributes(attributes) {
+    const attrs = Object.entries(attributes)
+        .map(([key, value]) => {
+        if (key.startsWith(':') && value === 'true') {
+            return key.slice(1);
+        }
+        if (key === 'id') {
+            return `#${value}`;
+        }
+        if (key === 'class') {
+            return value.split(' ').map(c => `.${c}`).join('');
+        }
+        if (typeof value === 'object') {
+            return `${key}="${JSON.stringify(value).replace(/"/g, '\\"')}"`;
+        }
+        return `${key}="${value}"`;
+    })
+        .join(' ');
+    return attrs.length > 0 ? `{${attrs}}` : '';
+}
+/**
+ * Convert attributes to a string of HTML attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export function htmlAttributes(attributes) {
+    return Object.entries(attributes)
+        .map(([key, value]) => {
+        if (key.startsWith(':')) {
+            if (value === 'true') {
+                return key.slice(1);
+            }
+            return `${key.slice(1)}="${value}"`;
+        }
+        if (value === 'true')
+            return key;
+        if (typeof value === 'object') {
+            return `${key}="${JSON.stringify(value).replace(/"/g, '\\"')}"`;
+        }
+        return `${key}="${value}"`;
+    })
+        .join(' ');
+}
+/**
+ * Convert attributes to a string of YAML attributes
+ *
+ * @param attributes - The attributes to stringify
+ * @returns The stringified attributes
+ */
+export function comarkYamlAttributes(attributes) {
+    // Normalize boolean attributes to remove the colon prefix
+    const normalized = Object.fromEntries(Object.entries(attributes).map(([key, value]) => {
+        if (key.startsWith(':') && (value === 'true' || value === 'false')) {
+            return [key.slice(1), value];
+        }
+        return [key, value];
+    }));
+    return `---\n${stringifyYaml(normalized).trim()}\n---`;
+}

package/dist/internal/stringify/handlers/a.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function a(node: ComarkElement, state: State): Promise<string>;

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

@@ -0,0 +1,11 @@
+import { comarkAttributes } from '../attributes';
+// TODO: support title & attributes
+export async function a(node, state) {
+    const [_, attrs] = node;
+    const { href, ...rest } = attrs;
+    const attrsString = Object.keys(rest).length > 0
+        ? comarkAttributes(rest)
+        : '';
+    const content = await state.flow(node, state);
+    return `[${content}](${href})${attrsString}`;
+}

package/dist/internal/stringify/handlers/blockquote.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function blockquote(node: ComarkElement, state: State): Promise<string>;

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

@@ -0,0 +1,18 @@
+export async function blockquote(node, state) {
+    const children = node.slice(2);
+    let childResult = '';
+    for (const child of children) {
+        childResult += await state.one(child, state, node);
+    }
+    const content = childResult
+        .trim()
+        .split('\n')
+        .map(line => line ? `> ${line}` : '>')
+        .join('\n');
+    if (node[1].as) {
+        return `> [!${String(node[1].as).toUpperCase()}]\n`
+            + content
+            + state.context.blockSeparator;
+    }
+    return content + state.context.blockSeparator;
+}

package/dist/internal/stringify/handlers/br.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function br(_: ComarkElement, _state: State): string;

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

@@ -0,0 +1,3 @@
+export function br(_, _state) {
+    return '  \n';
+}

package/dist/internal/stringify/handlers/code.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function code(node: ComarkElement, _state: State): string;

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

@@ -0,0 +1,11 @@
+import { comarkAttributes } from '../attributes';
+import { textContent } from 'comark/utils';
+export function code(node, _state) {
+    const [_, attrs] = node;
+    const attrsString = Object.keys(attrs).length > 0
+        ? comarkAttributes(attrs)
+        : '';
+    const content = textContent(node);
+    const fence = content.includes('`') ? '``' : '`';
+    return `${fence}${content}${fence}${attrsString}`;
+}

package/dist/internal/stringify/handlers/comment.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function comment(node: ComarkElement, _state: State): string;

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

@@ -0,0 +1,6 @@
+export function comment(node, _state) {
+    if (node[0] === null) {
+        return `<!--${node[2]}-->` + _state.context.blockSeparator;
+    }
+    return '';
+}

package/dist/internal/stringify/handlers/del.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function del(node: ComarkElement, _: State): string;

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

@@ -0,0 +1,4 @@
+import { textContent } from 'comark/utils';
+export function del(node, _) {
+    return `~~${textContent(node)}~~`;
+}

package/dist/internal/stringify/handlers/emphesis.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function emphesis(node: ComarkElement, state: State): Promise<string>;

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

@@ -0,0 +1,13 @@
+import { comarkAttributes } from '../attributes';
+export async function emphesis(node, state) {
+    const [_, attrs, ...children] = node;
+    let content = '';
+    for (const child of children) {
+        content += await state.one(child, state, node);
+    }
+    content = content.trim();
+    const attrsString = Object.keys(attrs).length > 0
+        ? comarkAttributes(attrs)
+        : '';
+    return `*${content}*${attrsString}`;
+}

package/dist/internal/stringify/handlers/heading.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function heading(node: ComarkElement, state: State): Promise<string>;

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

@@ -0,0 +1,7 @@
+// h1, h2, h3, h4, h5, h6
+export async function heading(node, state) {
+    const [tag] = node;
+    const level = Number(tag.slice(1));
+    const content = await state.flow(node, state);
+    return '#'.repeat(level) + ' ' + content + state.context.blockSeparator;
+}

package/dist/internal/stringify/handlers/hr.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function hr(_: ComarkElement, state: State): string;

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

@@ -0,0 +1,3 @@
+export function hr(_, state) {
+    return '---' + state.context.blockSeparator;
+}

package/dist/internal/stringify/handlers/html.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function html(node: ComarkElement, state: State, parent?: ComarkElement): Promise<string>;

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

@@ -0,0 +1,73 @@
+import { htmlAttributes } from '../attributes';
+import { indent } from '../indent';
+const textBlocks = new Set(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'td', 'th']);
+const selfCloseTags = new Set(['br', 'hr', 'img', 'input', 'link', 'meta', 'source', 'track', 'wbr']);
+const inlineTags = new Set(['strong', 'em', 'code', 'a', 'br', 'span', 'img']);
+const blockTags = new Set(['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'li', 'ul', 'ol', 'blockquote', 'hr', 'table', 'td', 'th']);
+export async function html(node, state, parent) {
+    const [tag, attr, ...children] = node;
+    const { $ = {}, ...attributes } = attr;
+    const hasOnlyTextChildren = children.every(child => typeof child === 'string' || inlineTags.has(String(child?.[0])));
+    const hasTextSibling = children.some(child => typeof child === 'string');
+    const isBlock = textBlocks.has(String(tag));
+    const isInline = inlineTags.has(String(tag)) && $.block === 0;
+    let oneLiner = isBlock && hasOnlyTextChildren;
+    if (!oneLiner && inlineTags.has(String(tag)) && hasOnlyTextChildren) {
+        oneLiner = true;
+    }
+    if (tag === 'pre') {
+        oneLiner = true;
+    }
+    // If parent is a paragraph, it is inline
+    if (parent?.[0] === 'p' || state.context.inline) {
+        oneLiner = true;
+    }
+    if ($.block === 0) {
+        oneLiner = true;
+    }
+    const isSelfClose = selfCloseTags.has(String(tag));
+    // Do not modify context if we are already in html mode
+    const revert = state.applyContext({ inline: oneLiner });
+    const childrenContent = [];
+    for (const child of children) {
+        childrenContent.push(await state.one(child, state, node));
+    }
+    let content = '';
+    let isPrevBlock = true;
+    for (let i = 0; i < children.length; i++) {
+        const childContent = childrenContent[i];
+        const child = children[i];
+        const isBlock = blockTags.has(String(child?.[0])) || (!inlineTags.has(String(child?.[0])) && !hasTextSibling);
+        if (i > 0 && !isPrevBlock && isBlock) {
+            content += state.context.blockSeparator;
+        }
+        content += childContent;
+        isPrevBlock = isBlock;
+        if (isBlock && i < children.length - 1) {
+            content += state.context.blockSeparator;
+        }
+    }
+    // Revert, only if we modified the context
+    if (revert) {
+        state.applyContext(revert);
+    }
+    const attrs = Object.keys(attributes).length > 0
+        ? ` ${htmlAttributes(attributes)}`
+        : '';
+    if (isSelfClose) {
+        return `<${tag}${attrs} />` + (!parent && !isInline ? state.context.blockSeparator : '');
+    }
+    if (!oneLiner && content) {
+        content = '\n' + paddNoneHtmlContent(content, state).trimEnd() + '\n';
+    }
+    return `<${tag}${attrs}>${content}</${tag}>`
+        + (!parent && !isInline ? state.context.blockSeparator : '');
+}
+function paddNoneHtmlContent(content, state) {
+    if (state.context.html) {
+        return indent(content);
+    }
+    return ((content.trim().startsWith('<') ? '' : '')
+        + content
+        + (content.trim().endsWith('>') ? '' : ''));
+}

package/dist/internal/stringify/handlers/img.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function img(node: ComarkElement, _state: State): string;

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

@@ -0,0 +1,9 @@
+import { comarkAttributes } from '../attributes';
+export function img(node, _state) {
+    const [_, attrs] = node;
+    const { title, src, alt, ...rest } = attrs;
+    const attrsString = Object.keys(rest).length > 0
+        ? comarkAttributes(rest)
+        : '';
+    return title ? `![${alt}](${src} "${title}")` : `![${alt}](${src})${attrsString}`;
+}

package/dist/internal/stringify/handlers/index.d.ts

@@ -0,0 +1,2 @@
+import type { NodeHandler } from 'comark/render';
+export declare const handlers: Record<string, NodeHandler>;

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

@@ -0,0 +1,56 @@
+import { code } from "./code.js";
+import { pre } from "./pre.js";
+import { hr } from "./hr.js";
+import { heading } from "./heading.js";
+import { p } from "./p.js";
+import { a } from "./a.js";
+import { ul } from "./ul.js";
+import { ol } from "./ol.js";
+import { li } from "./li.js";
+import { html } from "./html.js";
+import { strong } from "./strong.js";
+import { emphesis } from "./emphesis.js";
+import { blockquote } from "./blockquote.js";
+import { img } from "./img.js";
+import { del } from "./del.js";
+import { mdc } from "./mdc.js";
+import { br } from "./br.js";
+import { template } from "./template.js";
+import { table, thead, tbody, tr, th, td } from "./table.js";
+import { comment } from "./comment.js";
+import { math } from "./math.js";
+import { mermaid } from "./mermaid.js";
+export const handlers = {
+    code,
+    pre,
+    hr,
+    br,
+    h1: heading,
+    h2: heading,
+    h3: heading,
+    h4: heading,
+    h5: heading,
+    h6: heading,
+    p,
+    a,
+    ul,
+    ol,
+    li,
+    html,
+    strong,
+    em: emphesis,
+    blockquote,
+    img,
+    del,
+    mdc,
+    template,
+    table,
+    thead,
+    tbody,
+    tr,
+    th,
+    td,
+    comment,
+    math,
+    mermaid,
+};

package/dist/internal/stringify/handlers/li.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function li(node: ComarkElement, state: State): Promise<string>;

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

@@ -0,0 +1,43 @@
+export async function li(node, state) {
+    const children = node.slice(2);
+    const order = state.context.order;
+    let prefix = order ? `${order}. ` : '- ';
+    const className = node[1].className && Array.isArray(node[1].className)
+        ? node[1].className.join(' ')
+        : String(node[1].className || node[1].class);
+    const taskList = className.includes('task-list-item');
+    if (taskList) {
+        const input = children.shift();
+        prefix += input[1].checked || input[1][':checked'] ? '[x] ' : '[ ] ';
+    }
+    let result = '';
+    for (const child of children) {
+        result += await state.one(child, state, node);
+    }
+    result = result.trim();
+    if (!order) {
+        result = escapeLeadingNumberDot(result);
+    }
+    if (order) {
+        state.applyContext({ order: order + 1 });
+    }
+    return `${prefix}${result}\n`;
+}
+function escapeLeadingNumberDot(str) {
+    if (str.length === 0)
+        return str;
+    const len = str.length;
+    const firstChar = str.charCodeAt(0);
+    if (firstChar < 48 || firstChar > 57)
+        return str; // Not a digit
+    let i = 1;
+    for (; i < len; i++) {
+        const code = str.charCodeAt(i);
+        if (code < 48 || code > 57)
+            break;
+    }
+    if (i < len && str[i] === '.') {
+        return str.slice(0, i) + '\\.' + str.slice(i + 1);
+    }
+    return str;
+}

package/dist/internal/stringify/handlers/math.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function math(node: ComarkElement, state: State, parent?: ComarkElement): string;

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

@@ -0,0 +1,8 @@
+import { textContent } from 'comark/utils';
+export function math(node, state, parent) {
+    const content = textContent(node);
+    if (parent?.some((child, index) => index > 1 && typeof child === 'string')) {
+        return `$$${content}$$`;
+    }
+    return `$$\n${content}\n$$${state.context.blockSeparator}`;
+}

package/dist/internal/stringify/handlers/mdc.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function mdc(node: ComarkElement, state: State, parent?: ComarkElement): Promise<string>;

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

@@ -0,0 +1,47 @@
+import { indent } from "../indent.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;
+    if (tag === 'table') {
+        return html(node, state);
+    }
+    const attributeEntries = Object.entries(attributes);
+    const hasObjectAttributes = attributeEntries.some(([, value]) => typeof value === 'object');
+    // Component is inline if it has text siblings in parent
+    // or is inside an inline HTML element
+    const hasTextSiblings = parent?.some((child, index) => index > 1 && typeof child === 'string') ?? false;
+    const insideInlineElement = parent !== undefined && INLINE_HTML_ELEMENTS.has(String(parent[0]));
+    let inline = hasTextSiblings || insideInlineElement;
+    // if component has object attributes, it cannot be inline
+    if (hasObjectAttributes) {
+        inline = false;
+    }
+    let content = '';
+    const childState = { ...state, nodeDepthInTree: (state.nodeDepthInTree || 0) + 1 };
+    for (const child of children) {
+        content += await state.one(child, childState, node);
+    }
+    content = content.trimEnd();
+    const attrs = attributeEntries.length > 0 ? comarkAttributes(attributes) : '';
+    if (tag === 'span') {
+        return `[${content}]${attrs}`;
+    }
+    const fence = ':'.repeat((state.nodeDepthInTree || 0) + 2);
+    let result = `:${tag}${content && `[${content}]`}${attrs}` + (!parent ? state.context.blockSeparator : '');
+    if (!inline) {
+        const maxInlineAttributes = state.context.maxInlineAttributes ?? 3;
+        const useYaml = hasObjectAttributes || maxInlineAttributes === 0 || attributeEntries.length > maxInlineAttributes;
+        if (useYaml) {
+            const yamlAttrs = comarkYamlAttributes(attributes);
+            result = `${fence}${tag}\n${yamlAttrs}${content ? `\n${content}` : ''}\n${fence}` + state.context.blockSeparator;
+        }
+        else {
+            result = `${fence}${tag}${attrs}${content ? `\n${content}` : ''}\n${fence}` + state.context.blockSeparator;
+        }
+    }
+    return inline ? result : indent(result, { level: parent ? 1 : 0 });
+}

package/dist/internal/stringify/handlers/mermaid.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function mermaid(node: ComarkElement, state: State): string;

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

@@ -0,0 +1,8 @@
+import { comarkAttributes } from '../attributes';
+const fence = '```';
+export function mermaid(node, state) {
+    const [_, attributes] = node;
+    const { content, ...rest } = attributes;
+    const attrs = comarkAttributes(rest);
+    return `${fence}mermaid${attrs ? ` ${attrs}` : ''}\n${content}\n${fence}${state.context.blockSeparator}`;
+}

package/dist/internal/stringify/handlers/ol.d.ts

@@ -0,0 +1,3 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function ol(node: ComarkElement, state: State): Promise<string>;