comark 0.0.1 → 0.1.0

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

@@ -0,0 +1,18 @@
+import { indent } from '../indent';
+export async function ol(node, state) {
+    const children = node.slice(2);
+    const revert = state.applyContext({ list: true, order: 1 });
+    let result = '';
+    for (const child of children) {
+        result += await state.one(child, state);
+    }
+    result = result.trim();
+    if (revert.list) {
+        result = '\n' + indent(result);
+    }
+    else {
+        result = result + state.context.blockSeparator;
+    }
+    state.applyContext(revert);
+    return result;
+}

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

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

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

@@ -0,0 +1,8 @@
+export async function p(node, state) {
+    const children = node.slice(2);
+    let result = '';
+    for (const child of children) {
+        result += await state.one(child, state, node);
+    }
+    return result + state.context.blockSeparator;
+}

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

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

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

@@ -0,0 +1,60 @@
+import { textContent } from 'comark/utils';
+export function pre(node, state) {
+    const [_, attributes, ...children] = node;
+    const codeClasses = children[0]?.[1]?.class;
+    const language = (attributes.language || (codeClasses?.split(' ').find(cls => cls.startsWith('language-')))?.slice(9)) || '';
+    // Escape ] in filename
+    const filename = attributes.filename
+        ? ' [' + String(attributes.filename).split(']').join('\\\\]') + ']'
+        : '';
+    const highlights = attributes.highlights
+        ? ' {' + formatHighlights(attributes.highlights) + '}'
+        : '';
+    // Meta always has a leading space
+    const meta = attributes.meta
+        ? ' ' + attributes.meta
+        : '';
+    const result = '```' + language + filename + highlights + meta + '\n'
+        + String(node[1]?.code || extractCode(node)).trim()
+        + '\n```';
+    return result + state.context.blockSeparator;
+}
+function extractCode(node) {
+    const codeNode = node[2];
+    if (Array.isArray(codeNode) && codeNode[0] === 'code') {
+        const spans = codeNode.slice(2);
+        const lineSpans = spans.filter(s => Array.isArray(s) && String(s[1]?.class ?? '').includes('line'));
+        if (lineSpans.length > 0) {
+            return lineSpans.map(span => textContent(span)).join('\n');
+        }
+    }
+    return textContent(node);
+}
+function formatHighlights(highlights) {
+    if (highlights.length === 0)
+        return '';
+    const sorted = [...highlights].sort((a, b) => a - b);
+    const ranges = [];
+    let start = sorted[0];
+    let end = sorted[0];
+    for (let i = 1; i <= sorted.length; i++) {
+        if (i < sorted.length && sorted[i] === end + 1) {
+            end = sorted[i];
+        }
+        else {
+            // Add the current range
+            if (start === end) {
+                ranges.push(String(start));
+            }
+            else {
+                ranges.push(start + '-' + end);
+            }
+            // Start a new range
+            if (i < sorted.length) {
+                start = sorted[i];
+                end = sorted[i];
+            }
+        }
+    }
+    return ranges.join(',');
+}

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

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

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

@@ -0,0 +1,13 @@
+import { comarkAttributes } from '../attributes';
+export async function strong(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/table.d.ts

@@ -0,0 +1,8 @@
+import type { State } from 'comark/render';
+import type { ComarkElement } from 'comark';
+export declare function table(node: ComarkElement, state: State): Promise<string>;
+export declare function thead(_node: ComarkElement, _state: State): string;
+export declare function tbody(_node: ComarkElement, _state: State): string;
+export declare function tr(_node: ComarkElement, _state: State): string;
+export declare function th(_node: ComarkElement, _state: State): string;
+export declare function td(_node: ComarkElement, _state: State): string;

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

@@ -0,0 +1,180 @@
+// Helper function to extract alignment from style attribute
+function getAlignment(attributes) {
+    const style = attributes.style;
+    if (typeof style !== 'string') {
+        return null;
+    }
+    // Parse text-align from style attribute - normalize and check
+    const normalized = style.toLowerCase().split(' ').join('').split('\t').join('');
+    if (normalized.includes('text-align:left')) {
+        return 'left';
+    }
+    if (normalized.includes('text-align:center')) {
+        return 'center';
+    }
+    if (normalized.includes('text-align:right')) {
+        return 'right';
+    }
+    return null;
+}
+// Helper function to extract text content from a cell
+async function getCellContent(cell, state) {
+    if (typeof cell === 'string') {
+        return escapePipes(cell);
+    }
+    const [, , ...children] = cell;
+    let content = '';
+    for (const child of children) {
+        if (typeof child === 'string') {
+            content += child;
+        }
+        else {
+            content += await state.one(child, state, cell);
+        }
+    }
+    return escapePipes(content.trim());
+}
+// Helper function to escape pipe characters and handle newlines
+function escapePipes(text) {
+    // Replace newlines with spaces (tables don't support multi-line cells)
+    // Then escape pipe characters
+    return text.split('\n').join(' ').split('|').join('\\|');
+}
+// Helper function to get all rows from thead/tbody
+function getRows(element) {
+    if (typeof element === 'string') {
+        return [];
+    }
+    const [tag, , ...children] = element;
+    // If it's a tr, return it directly
+    if (tag === 'tr') {
+        return [element];
+    }
+    // If it's thead/tbody, extract tr elements
+    if (tag === 'thead' || tag === 'tbody') {
+        return children.filter(child => typeof child !== 'string' && child[0] === 'tr');
+    }
+    return [];
+}
+// Helper function to get cells from a row
+function getCells(row) {
+    const [, , ...children] = row;
+    return children.filter(child => typeof child !== 'string' && (child[0] === 'th' || child[0] === 'td'));
+}
+export async function table(node, state) {
+    const [, , ...children] = node;
+    // Extract thead and tbody
+    let headerRows = [];
+    let bodyRows = [];
+    for (const child of children) {
+        if (typeof child === 'string')
+            continue;
+        const [tag] = child;
+        if (tag === 'thead') {
+            headerRows = getRows(child);
+        }
+        else if (tag === 'tbody') {
+            bodyRows = getRows(child);
+        }
+        else if (tag === 'tr') {
+            // Direct tr children (no thead/tbody wrapper)
+            const cells = getCells(child);
+            if (cells.length > 0 && cells[0][0] === 'th') {
+                headerRows.push(child);
+            }
+            else {
+                bodyRows.push(child);
+            }
+        }
+    }
+    // If no header rows, create a default header based on the first body row
+    if (headerRows.length === 0 && bodyRows.length > 0) {
+        const firstRow = bodyRows[0];
+        const cells = getCells(firstRow);
+        const headerCells = cells.map((_, i) => ['th', {}, `Column ${i + 1}`]);
+        headerRows = [['tr', {}, ...headerCells]];
+    }
+    if (headerRows.length === 0) {
+        return '';
+    }
+    // Process header row (use the first header row)
+    const headerRow = headerRows[0];
+    const headerCells = getCells(headerRow);
+    const headerContent = [];
+    for (const cell of headerCells) {
+        headerContent.push(await getCellContent(cell, state));
+    }
+    // Extract alignment from header cells
+    const alignments = headerCells.map((cell) => {
+        const [, attributes] = cell;
+        return getAlignment(attributes);
+    });
+    // Calculate column widths (minimum 3 characters per column)
+    const columnWidths = headerContent.map(content => Math.max(3, content.length));
+    // Update column widths based on body content
+    for (const row of bodyRows) {
+        const cells = getCells(row);
+        for (let i = 0; i < cells.length; i++) {
+            if (i < columnWidths.length) {
+                const content = await getCellContent(cells[i], state);
+                columnWidths[i] = Math.max(columnWidths[i], content.length);
+            }
+        }
+    }
+    // Build the markdown table
+    let result = '| ';
+    result += headerContent.map((content, i) => content.padEnd(columnWidths[i])).join(' | ');
+    result += ' |\n';
+    // Add separator row with alignment
+    result += '| ';
+    result += columnWidths.map((width, i) => {
+        const alignment = alignments[i];
+        if (alignment === 'left') {
+            return ':' + '-'.repeat(width - 1);
+        }
+        else if (alignment === 'center') {
+            return ':' + '-'.repeat(width - 2) + ':';
+        }
+        else if (alignment === 'right') {
+            return '-'.repeat(width - 1) + ':';
+        }
+        return '-'.repeat(width);
+    }).join(' | ');
+    result += ' |\n';
+    // Add body rows
+    for (const row of bodyRows) {
+        const cells = getCells(row);
+        const cellContents = [];
+        for (let i = 0; i < cells.length; i++) {
+            const content = await getCellContent(cells[i], state);
+            cellContents.push(content.padEnd(columnWidths[i] || 0));
+        }
+        // Fill missing columns with empty cells
+        while (cellContents.length < columnWidths.length) {
+            cellContents.push(''.padEnd(columnWidths[cellContents.length]));
+        }
+        result += '| ' + cellContents.join(' | ') + ' |\n';
+    }
+    // result already ends with \n, so we only need to add one more \n
+    return result + '\n';
+}
+export function thead(_node, _state) {
+    // thead is handled by the table handler
+    return '';
+}
+export function tbody(_node, _state) {
+    // tbody is handled by the table handler
+    return '';
+}
+export function tr(_node, _state) {
+    // tr is handled by the table handler
+    return '';
+}
+export function th(_node, _state) {
+    // th is handled by the table handler
+    return '';
+}
+export function td(_node, _state) {
+    // td is handled by the table handler
+    return '';
+}

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

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

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

@@ -0,0 +1,14 @@
+// slot template
+export async function template(node, state, parent) {
+    const [_, attrs] = node;
+    const content = (await state.flow(node, state)).trim();
+    // Omit #default marker if this is the only slot
+    if (attrs.name === 'default') {
+        const siblings = parent ? parent.slice(2) : [];
+        const templateCount = siblings.filter(child => Array.isArray(child) && child[0] === 'template').length;
+        if (templateCount === 1) {
+            return content + state.context.blockSeparator;
+        }
+    }
+    return `#${attrs.name}\n${content}` + state.context.blockSeparator;
+}

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

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

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

@@ -0,0 +1,18 @@
+import { indent } from '../indent';
+export async function ul(node, state) {
+    const children = node.slice(2);
+    const revert = state.applyContext({ list: true, order: false });
+    let result = '';
+    for (const child of children) {
+        result += await state.one(child, state);
+    }
+    result = result.trim();
+    if (revert.list) {
+        result = '\n' + indent(result);
+    }
+    else {
+        result = result + state.context.blockSeparator;
+    }
+    state.applyContext(revert);
+    return result;
+}

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

@@ -0,0 +1,4 @@
+export declare function indent(text: string, { ignoreFirstLine, level }?: {
+    ignoreFirstLine?: boolean;
+    level?: number;
+}): string;

package/dist/internal/stringify/indent.js

@@ -0,0 +1,8 @@
+export function indent(text, { ignoreFirstLine = false, level = 1 } = {}) {
+    return text.split('\n').map((line, index) => {
+        if (ignoreFirstLine && index === 0) {
+            return line;
+        }
+        return line ? '  '.repeat(level) + line : line;
+    }).join('\n');
+}

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

@@ -0,0 +1,13 @@
+import type { State, Context } from 'comark/render';
+import type { ComarkElement, ComarkNode } from 'comark';
+/**
+ * Render a single node
+ * @param node - The node to render
+ * @param state - The state of the renderer
+ * @param parent - The parent node
+ * @returns The rendered node
+ */
+export declare function one(node: ComarkNode, state: State, parent?: ComarkElement): Promise<string>;
+export declare function flow(node: ComarkElement, state: State, parent?: ComarkElement): Promise<string>;
+export declare function createState(ctx?: Partial<Context>): State;
+export declare const state: State;

package/dist/internal/stringify/state.js

@@ -0,0 +1,121 @@
+import { handlers } from "./handlers/index.js";
+import { pascalCase } from "../../utils/index.js";
+/**
+ * Render a single node
+ * @param node - The node to render
+ * @param state - The state of the renderer
+ * @param parent - The parent node
+ * @returns The rendered node
+ */
+export async function one(node, state, parent) {
+    if (typeof node === 'string') {
+        if (state.context.html) {
+            return escapeHtml(node);
+        }
+        return node;
+    }
+    if (node[0] === null) {
+        return await state.handlers.comment(node, state);
+    }
+    const userHandler = state.context.handlers[node[0]] || state.context.handlers[pascalCase(node[0])];
+    if (userHandler) {
+        return await userHandler(node, state, parent);
+    }
+    if (state.context.html || node[1].$?.html === 1) {
+        return await state.handlers.html(node, state, parent);
+    }
+    const nodeHandler = state.handlers[node[0]];
+    if (nodeHandler) {
+        return await nodeHandler(node, state, parent);
+    }
+    return state.context.format === 'markdown/comark'
+        ? await state.handlers.mdc(node, state, parent)
+        : await state.handlers.html(node, state, parent);
+}
+export async function flow(node, state, parent) {
+    const children = node.slice(2);
+    let result = '';
+    for (const child of children) {
+        result += await one(child, state, parent || node);
+    }
+    return result;
+}
+export function createState(ctx = {}) {
+    const context = {
+        ...ctx,
+        blockSeparator: ctx.blockSeparator || '\n\n',
+        format: ctx.format || 'markdown/comark',
+        handlers: ctx.handlers || {}, // user defined node handlers
+        // Enable html mode for text/html format
+        html: ctx.format === 'text/html',
+    };
+    const state = {
+        handlers,
+        context,
+        one,
+        flow,
+        data: ctx.data || {},
+        render: async (input) => {
+            if (Array.isArray(input) && typeof input[0] === 'string' && input.length > 1) {
+                return state.one(input, state);
+            }
+            let result = '';
+            for (const child of input) {
+                result += await state.one(child, state);
+            }
+            return result;
+        },
+        applyContext: (edit) => {
+            const revert = {};
+            for (const [key, value] of Object.entries(edit)) {
+                revert[key] = context[key];
+                context[key] = value;
+            }
+            return revert;
+        },
+    };
+    return state;
+}
+export const state = {
+    handlers,
+    data: {},
+    context: {
+        blockSeparator: '\n\n',
+        format: 'markdown/comark',
+        handlers: {}, // user defined node handlers
+    },
+    flow,
+    one,
+    render: async (input) => {
+        if (typeof input === 'string') {
+            return input;
+        }
+        if (Array.isArray(input) && typeof input[0] === 'string') {
+            return one(input, state);
+        }
+        let result = '';
+        for (const child of input) {
+            result += await one(child, state);
+        }
+        return result;
+    },
+    applyContext: (edit) => {
+        const revert = {};
+        for (const [key, value] of Object.entries(edit)) {
+            revert[key] = state.context[key];
+            state.context[key] = value;
+        }
+        return revert;
+    },
+};
+/**
+ * Escape HTML special characters
+ */
+function escapeHtml(text) {
+    const map = {
+        '<': '&lt;',
+        '>': '&gt;',
+        '&amp;': '&',
+    };
+    return text.replace(/[<>]/g, char => map[char]);
+}

package/dist/internal/yaml.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Parse YAML content
+ * @param content - The content to parse
+ * @returns The parsed data
+ */
+export declare function parseYaml(content: string): Record<string, unknown>;
+/**
+ * Stringify YAML data
+ * @param data - The data to stringify
+ * @returns The stringified data
+ */
+export declare function stringifyYaml(data: Record<string, unknown>): string;

package/dist/internal/yaml.js

@@ -0,0 +1,51 @@
+import { dump, JSON_SCHEMA, load } from 'js-yaml';
+/**
+ * Parse YAML content
+ * @param content - The content to parse
+ * @returns The parsed data
+ */
+export function parseYaml(content) {
+    return load(content, { schema: JSON_SCHEMA });
+}
+/**
+ * Stringify YAML data
+ * @param data - The data to stringify
+ * @returns The stringified data
+ */
+export function stringifyYaml(data) {
+    const yamlOutput = dump(data, {
+        indent: 2,
+        replacer: (_key, value) => {
+            if (value === 'true')
+                return true;
+            if (value === 'false')
+                return false;
+            return value;
+        },
+    });
+    /**
+     * js-yaml wraps keys with quotes if they start with a colon. This function removes the quotes.
+     * `':test': true` becomes `:test: true`
+     *
+     * Using js-yaml and this function is faster than using other libraries like yaml.
+     */
+    const lines = yamlOutput.split('\n');
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        const trimmed = line.trimStart();
+        // Check if line starts with a quote followed by colon
+        if (trimmed[0] === '\'' || trimmed[0] === '"') {
+            const quote = trimmed[0];
+            if (trimmed[1] === ':') {
+                // Find the closing quote
+                const quoteEnd = trimmed.indexOf(quote, 1);
+                if (quoteEnd > 1 && trimmed[quoteEnd + 1] === ':') {
+                    // Remove quotes: keep indentation + unquoted key + rest
+                    const indent = line.length - trimmed.length;
+                    lines[i] = ' '.repeat(indent) + trimmed.slice(1, quoteEnd) + trimmed.slice(quoteEnd + 1);
+                }
+            }
+        }
+    }
+    return lines.join('\n');
+}

package/dist/parse.d.ts

@@ -0,0 +1,66 @@
+import type { ComarkParseFn, ParseOptions, ComarkTree } from './types.ts';
+export { parseFrontmatter } from './internal/frontmatter.ts';
+/**
+ * Creates a parser function for Comark content.
+ *
+ * Returns an async function that takes a markdown string and returns a Promise resolving to a ComarkTree AST.
+ * The returned parser applies frontmatter extraction, Comark syntax parsing, token-to-AST conversion,
+ * auto-closing of incomplete markdown, optional AST transformations and plugin hooks.
+ *
+ * @param options - Parser options controlling parsing behavior.
+ * @returns An async parser function: (markdown) => Promise<ComarkTree>
+ *
+ * @example
+ * ```typescript
+ * import { createParse } from 'comark'
+ *
+ * const parse = createParse({ autoUnwrap: false })
+ * const tree = await parse('# Hello **World**\n::alert\nhi\n::')
+ * console.log(tree.nodes)
+ * // → [ ['h1', { id: 'hello-world' }, 'Hello ', ['strong', {}, 'World'] ], ['alert', {}, 'hi'] ]
+ *
+ * // Enable HTML parsing (on by default) — HTML tags are included in the AST
+ * const parseWithHtml = createParse({ html: true })
+ * const tree2 = await parseWithHtml('<strong class="bold">Hello</strong> _world_')
+ * console.log(tree2.nodes)
+ * // → [ ['strong', { class: 'bold' }, 'Hello'], ' ', ['em', {}, 'world'] ]
+ *
+ * // Disable HTML parsing — HTML tags are treated as plain text
+ * const parseNoHtml = createParse({ html: false })
+ * ```
+ */
+export declare function createParse(options?: ParseOptions): ComarkParseFn;
+/**
+ * Parse Comark content from a string
+ *
+ * @param markdown - The markdown/Comark content as a string
+ * @param options - Parser options
+ * @returns ComarkTree - The parsed AST tree
+ *
+ * @example
+ * ```typescript
+ * import { parse } from 'comark'
+ *
+ * const content = `---
+ * title: Hello World
+ * ---
+ *
+ * # Hello World
+ *
+ * This is a **markdown** document with *Comark* components.
+ *
+ * ::alert{type="info"}
+ * This is an alert component
+ * ::
+ * `
+ *
+ * const tree = await parse(content)
+ * console.log(tree.nodes)        // Array of AST nodes
+ * console.log(tree.frontmatter)  // { title: 'Hello World' }
+ * console.log(tree.meta)         // Additional metadata
+ *
+ * // Disable auto-unwrap
+ * const tree2 = await parse(content, { autoUnwrap: false })
+ * ```
+ */
+export declare function parse(markdown: string, options?: ParseOptions): Promise<ComarkTree>;