comark 0.0.1 → 0.1.1

package/dist/internal/parse/auto-close/table.js

@@ -0,0 +1,161 @@
+/**
+ * Parse cell widths from a table row (respects escaped pipes \|)
+ */
+function parseCellWidths(row) {
+    const widths = [];
+    let cellContent = '';
+    let inCell = false;
+    for (let i = 0; i < row.length; i++) {
+        const ch = row[i];
+        const isEscapedPipe = ch === '|' && i > 0 && row[i - 1] === '\\';
+        if (ch === '|' && !isEscapedPipe) {
+            if (inCell && cellContent) {
+                widths.push(cellContent.length);
+                cellContent = '';
+            }
+            inCell = true;
+        }
+        else if (inCell) {
+            cellContent += ch;
+        }
+    }
+    // Capture last cell if no trailing pipe
+    if (inCell && cellContent) {
+        widths.push(cellContent.length);
+    }
+    return widths;
+}
+/**
+ * Parse cell contents from a table row (respects escaped pipes \|)
+ */
+function parseCells(row) {
+    const cells = [];
+    let cell = '';
+    let inCell = false;
+    for (let i = 0; i < row.length; i++) {
+        const ch = row[i];
+        const isEscapedPipe = ch === '|' && i > 0 && row[i - 1] === '\\';
+        if (ch === '|' && !isEscapedPipe) {
+            if (inCell) {
+                cells.push(cell.trim());
+                cell = '';
+            }
+            inCell = true;
+        }
+        else if (inCell) {
+            cell += ch;
+        }
+    }
+    // Capture last cell if any
+    if (cell.trim()) {
+        cells.push(cell.trim());
+    }
+    return cells;
+}
+/**
+ * Closes unclosed markdown tables
+ */
+export function closeTables(markdown) {
+    const lines = markdown.split('\n');
+    // Group consecutive table rows (lines starting with |) into blocks
+    const tableBlocks = [];
+    let blockStart = -1;
+    for (let i = 0; i < lines.length; i++) {
+        if (lines[i].trim().startsWith('|')) {
+            if (blockStart === -1)
+                blockStart = i;
+        }
+        else if (blockStart !== -1) {
+            tableBlocks.push({ start: blockStart, end: i - 1 });
+            blockStart = -1;
+        }
+    }
+    if (blockStart !== -1) {
+        tableBlocks.push({ start: blockStart, end: lines.length - 1 });
+    }
+    if (tableBlocks.length === 0)
+        return markdown;
+    // Process last table
+    const { start, end } = tableBlocks[tableBlocks.length - 1];
+    const headerLine = lines[start].trim();
+    // Ensure header has trailing pipe
+    if (!headerLine.endsWith('|')) {
+        lines[start] += ' |';
+    }
+    // Count columns from header
+    const columnCount = parseCellWidths(lines[start].trim()).length;
+    const generateSeparator = () => '| ' + Array(columnCount).fill('---').join(' | ') + ' |';
+    // Check if separator exists (including incomplete ones with just :)
+    const secondLine = end - start >= 1 ? lines[start + 1].trim() : '';
+    const hasSeparator = secondLine.startsWith('|')
+        && (secondLine.includes('-') || secondLine.includes(':'));
+    // Handle last line
+    const lastLine = lines[end].trim();
+    const isSeparator = lastLine.startsWith('|')
+        && (lastLine.includes('-') || lastLine.includes(':'));
+    if (isSeparator) {
+        // Parse and complete separator cells
+        const sepCells = parseCells(lastLine);
+        // Complete each cell: ensure minimum dash count
+        const completedCells = sepCells.map((cell) => {
+            const hasLeftAlign = cell.startsWith(':');
+            const hasRightAlign = cell.endsWith(':') && cell.length > 1;
+            // Strip alignment markers to count dashes
+            let dashes = cell.replace(/^:/, '').replace(/:$/, '');
+            // Ensure at least 1 dash (alignment markers don't need extra length)
+            if (hasLeftAlign && hasRightAlign) {
+                // Center align :-:
+                if (dashes.length < 1)
+                    dashes = '-';
+                return ':' + dashes + ':';
+            }
+            else if (hasLeftAlign) {
+                // Left align :-
+                if (dashes.length < 1)
+                    dashes = '-';
+                return ':' + dashes;
+            }
+            else if (hasRightAlign) {
+                // Right align -:
+                if (dashes.length < 1)
+                    dashes = '-';
+                return dashes + ':';
+            }
+            else {
+                // No align ---
+                while (dashes.length < 3)
+                    dashes += '-';
+                return dashes;
+            }
+        });
+        // Add missing columns
+        while (completedCells.length < columnCount) {
+            completedCells.push('---');
+        }
+        lines[end] = '| ' + completedCells.join(' | ') + ' |';
+    }
+    else if (lastLine.startsWith('|') && !lastLine.endsWith('|')) {
+        // Complete data row - find reference widths and pad
+        let refRow = lines[start].trim();
+        for (let i = start + (hasSeparator ? 2 : 1); i < end; i++) {
+            const row = lines[i].trim();
+            if (row.startsWith('|') && row.endsWith('|') && !row.includes('-')) {
+                refRow = row;
+                break;
+            }
+        }
+        const refWidths = parseCellWidths(refRow);
+        const cells = parseCells(lastLine);
+        // Rebuild with padding
+        lines[end] = '| ' + cells.map((cell, i) => {
+            const targetWidth = refWidths[i] || cell.length + 2;
+            const padding = ' '.repeat(Math.max(0, targetWidth - cell.length - 2));
+            return cell + padding;
+        }).join(' | ') + ' |';
+    }
+    // Add separator if missing
+    if (!hasSeparator) {
+        lines.splice(start + 1, 0, generateSeparator());
+    }
+    return lines.join('\n');
+}

package/dist/internal/parse/auto-unwrap.d.ts

@@ -0,0 +1,20 @@
+import type { ComarkNode } from 'comark';
+/**
+ * Applies automatic unwrapping to container components.
+ *
+ * This utility removes unnecessary paragraph wrappers from container component children.
+ * If a container has only a single paragraph child (and no other block elements),
+ * the paragraph is unwrapped and its children are hoisted up to be direct children
+ * of the container.
+ *
+ * @param node - The Comark element to process
+ * @returns The node with auto-unwrapped children (if applicable)
+ *
+ * @example
+ * // Before:
+ * { tag: 'alert', children: [{ type: 'element', tag: 'p', children: [{ type: 'text', value: 'Text' }] }] }
+ *
+ * // After:
+ * { tag: 'alert', children: [{ type: 'text', value: 'Text' }] }
+ */
+export declare function applyAutoUnwrap(node: ComarkNode): ComarkNode;

package/dist/internal/parse/auto-unwrap.js

@@ -0,0 +1,42 @@
+/**
+ * Applies automatic unwrapping to container components.
+ *
+ * This utility removes unnecessary paragraph wrappers from container component children.
+ * If a container has only a single paragraph child (and no other block elements),
+ * the paragraph is unwrapped and its children are hoisted up to be direct children
+ * of the container.
+ *
+ * @param node - The Comark element to process
+ * @returns The node with auto-unwrapped children (if applicable)
+ *
+ * @example
+ * // Before:
+ * { tag: 'alert', children: [{ type: 'element', tag: 'p', children: [{ type: 'text', value: 'Text' }] }] }
+ *
+ * // After:
+ * { tag: 'alert', children: [{ type: 'text', value: 'Text' }] }
+ */
+export function applyAutoUnwrap(node) {
+    if (typeof node === 'string' || node.length < 2) {
+        return node;
+    }
+    const [tag, props, ...children] = node;
+    // Filter out empty text nodes for checking
+    const nonEmptyChildren = children.filter((child) => typeof child !== 'string' || (child && child.trim()));
+    if (nonEmptyChildren.length === 0) {
+        return node;
+    }
+    // Check if we have exactly one paragraph child (and possibly empty text nodes)
+    if (nonEmptyChildren.length > 1 || typeof nonEmptyChildren[0] === 'string' || nonEmptyChildren[0][0] !== 'p') {
+        return [
+            tag,
+            props,
+            ...children.map((child) => applyAutoUnwrap(child)),
+        ];
+    }
+    return [
+        tag,
+        props,
+        ...nonEmptyChildren[0].slice(2),
+    ];
+}

package/dist/internal/parse/html/html_block_rule.d.ts

@@ -0,0 +1,2 @@
+import type { StateBlock } from 'markdown-exit';
+export default function html_block(state: StateBlock, startLine: number, endLine: number, silent: boolean): boolean;

package/dist/internal/parse/html/html_block_rule.js

@@ -0,0 +1,60 @@
+// BASED ON https://github.com/serkodev/markdown-exit/blob/fe1351070a5841426223ab4a0a5c7874ba2b1257/packages/markdown-exit/src/parser/block/rules/html_block.ts
+import block_names from "./html_blocks.js";
+import { HTML_OPEN_CLOSE_TAG_RE } from "./html_re.js";
+// An array of opening and corresponding closing sequences for html tags,
+// last argument defines whether it can terminate a paragraph or not
+//
+const HTML_SEQUENCES = [
+    [new RegExp(`${HTML_OPEN_CLOSE_TAG_RE.source}\\s*$`), /^<\/[^>]+>$/, true],
+    [/^<(script|pre|style|textarea)(?=(\s|>|$))/i, /<\/(script|pre|style|textarea)>/i, true],
+    [/^<!--/, /-->/, true],
+    [/^<\?/, /\?>/, true],
+    [/^<![A-Z]/, />/, true],
+    [/^<!\[CDATA\[/, /\]\]>/, true],
+    [new RegExp(`^</?(${block_names.join('|')})(?=(\\s|/?>|$))`, 'i'), /^$/, true],
+    [new RegExp(`${HTML_OPEN_CLOSE_TAG_RE.source}\\s*$`), /^$/, false],
+];
+export default function html_block(state, startLine, endLine, silent) {
+    let pos = state.bMarks[startLine] + state.tShift[startLine];
+    let max = state.eMarks[startLine];
+    // if it's indented more than 3 spaces, it should be a code block
+    if (state.sCount[startLine] - state.blkIndent >= 4)
+        return false;
+    if (state.src.charCodeAt(pos) !== 0x3C /* < */)
+        return false;
+    let lineText = state.src.slice(pos, max);
+    let i = 0;
+    for (; i < HTML_SEQUENCES.length; i++) {
+        if (HTML_SEQUENCES[i][0].test(lineText))
+            break;
+    }
+    if (i === HTML_SEQUENCES.length)
+        return false;
+    if (silent) {
+        // true if this sequence can be a terminator, false otherwise
+        return HTML_SEQUENCES[i][2];
+    }
+    let nextLine = startLine + 1;
+    // If we are here - we detected HTML block.
+    // Let's roll down till block end.
+    if (i !== 0 && !HTML_SEQUENCES[i][1].test(lineText)) {
+        for (; nextLine < endLine; nextLine++) {
+            if (state.sCount[nextLine] < state.blkIndent) {
+                break;
+            }
+            pos = state.bMarks[nextLine] + state.tShift[nextLine];
+            max = state.eMarks[nextLine];
+            lineText = state.src.slice(pos, max);
+            if (HTML_SEQUENCES[i][1].test(lineText)) {
+                if (lineText.length !== 0)
+                    nextLine++;
+                break;
+            }
+        }
+    }
+    state.line = nextLine;
+    const token = lineText.startsWith('</') ? state.push('html_block_close', '', -1) : state.push('html_block', '', 1);
+    token.map = [startLine, nextLine];
+    token.content = state.getLines(startLine, nextLine, state.blkIndent, true);
+    return true;
+}

package/dist/internal/parse/html/html_blocks.d.ts

@@ -0,0 +1,2 @@
+declare const _default: string[];
+export default _default;

package/dist/internal/parse/html/html_blocks.js

@@ -0,0 +1,66 @@
+// List of valid html blocks names, according to commonmark spec
+// https://spec.commonmark.org/0.30/#html-blocks
+export default [
+    'address',
+    'article',
+    'aside',
+    'base',
+    'basefont',
+    'blockquote',
+    'body',
+    'caption',
+    'center',
+    'col',
+    'colgroup',
+    'dd',
+    'details',
+    'dialog',
+    'dir',
+    'div',
+    'dl',
+    'dt',
+    'fieldset',
+    'figcaption',
+    'figure',
+    'footer',
+    'form',
+    'frame',
+    'frameset',
+    'h1',
+    'h2',
+    'h3',
+    'h4',
+    'h5',
+    'h6',
+    'head',
+    'header',
+    'hr',
+    'html',
+    'iframe',
+    'legend',
+    'li',
+    'link',
+    'main',
+    'menu',
+    'menuitem',
+    'nav',
+    'noframes',
+    'ol',
+    'optgroup',
+    'option',
+    'p',
+    'param',
+    'search',
+    'section',
+    'summary',
+    'table',
+    'tbody',
+    'td',
+    'tfoot',
+    'th',
+    'thead',
+    'title',
+    'tr',
+    'track',
+    'ul',
+];

package/dist/internal/parse/html/html_inline_rule.d.ts

@@ -0,0 +1,2 @@
+import type { StateInline } from 'markdown-exit';
+export default function html_inline(state: StateInline, silent: boolean): boolean;

package/dist/internal/parse/html/html_inline_rule.js

@@ -0,0 +1,43 @@
+// BASED ON https://github.com/serkodev/markdown-exit/blob/fe1351070a5841426223ab4a0a5c7874ba2b1257/packages/markdown-exit/src/parser/inline/rules/html_inline.ts
+import { HTML_TAG_RE } from "./html_re.js";
+function isLinkOpen(str) {
+    return /^<a[>\s]/i.test(str);
+}
+function isLinkClose(str) {
+    return /^<\/a\s*>/i.test(str);
+}
+function isLetter(ch) {
+    /* eslint no-bitwise:0 */
+    const lc = ch | 0x20; // to lower case
+    return (lc >= 0x61 /* a */) && (lc <= 0x7A /* z */);
+}
+export default function html_inline(state, silent) {
+    // Check start
+    const max = state.posMax;
+    const pos = state.pos;
+    if (state.src.charCodeAt(pos) !== 0x3C
+        || /* < */ pos + 2 >= max) {
+        return false;
+    }
+    // Quick fail on second char
+    const ch = state.src.charCodeAt(pos + 1);
+    if (ch !== 0x21
+        && /* ! */ ch !== 0x3F
+        && /* ? */ ch !== 0x2F
+        && /* / */ !isLetter(ch)) {
+        return false;
+    }
+    const match = state.src.slice(pos).match(HTML_TAG_RE);
+    if (!match)
+        return false;
+    if (!silent) {
+        const token = state.push('html_inline', '', 0);
+        token.content = match[0];
+        if (isLinkOpen(token.content))
+            state.linkLevel++;
+        if (isLinkClose(token.content))
+            state.linkLevel--;
+    }
+    state.pos += match[0].length;
+    return true;
+}

package/dist/internal/parse/html/html_re.d.ts

@@ -0,0 +1,3 @@
+declare const HTML_TAG_RE: RegExp;
+declare const HTML_OPEN_CLOSE_TAG_RE: RegExp;
+export { HTML_OPEN_CLOSE_TAG_RE, HTML_TAG_RE };

package/dist/internal/parse/html/html_re.js

@@ -0,0 +1,18 @@
+// Regexps to match html elements
+const attr_name = '[a-zA-Z_:][a-zA-Z0-9:._-]*';
+const unquoted = '[^"\'=<>`\\x00-\\x20]+';
+const single_quoted = '\'[^\']*\'';
+const double_quoted = '"[^"]*"';
+const attr_value = `(?:${unquoted}|${single_quoted}|${double_quoted})`;
+const attribute = `(?:\\s+${attr_name}(?:\\s*=\\s*${attr_value})?)`;
+const open_tag = `<[A-Za-z][A-Za-z0-9\\-]*${attribute}*\\s*\\/?>`;
+const close_tag = '<\\/[A-Za-z][A-Za-z0-9\\-]*\\s*>';
+const comment = '<!---?>|<!--(?:[^-]|-[^-]|--[^>])*-->';
+const processing = '<\\?[\\s\\S]*?\\?>';
+const declaration = '<![A-Za-z][^>]*>';
+const cdata = '<!\\[CDATA\\[[\\s\\S]*?\\]\\]>';
+// eslint-disable-next-line regexp/no-super-linear-backtracking, regexp/prefer-w
+const HTML_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag}|${comment}|${processing}|${declaration}|${cdata})`);
+// eslint-disable-next-line regexp/use-ignore-case, regexp/no-super-linear-backtracking, regexp/prefer-w
+const HTML_OPEN_CLOSE_TAG_RE = new RegExp(`^(?:${open_tag}|${close_tag})`);
+export { HTML_OPEN_CLOSE_TAG_RE, HTML_TAG_RE };

package/dist/internal/parse/html/index.d.ts

@@ -0,0 +1,18 @@
+import type { ComarkNode } from 'comark';
+interface HtmlTagInfo {
+    tag: string;
+    attrs: Record<string, unknown>;
+    isVoid: boolean;
+    isClose: boolean;
+}
+/**
+ * Parse a single inline HTML tag fragment (opening, closing, or void).
+ * Returns null if the content is not a recognisable HTML tag.
+ */
+export declare function parseInlineHtmlTag(html: string): HtmlTagInfo | null;
+/**
+ * Parse a full HTML string into ComarkNodes using htmlparser2.
+ * Handles nested elements, text, void elements, and comments.
+ */
+export declare function htmlToComarkNodes(html: string): ComarkNode[];
+export {};

package/dist/internal/parse/html/index.js

@@ -0,0 +1,122 @@
+import { Parser } from 'htmlparser2';
+const VOID_ELEMENTS = new Set([
+    'area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input',
+    'link', 'meta', 'param', 'source', 'track', 'wbr',
+]);
+function attribsToComarkAttrs(attribs, isInline = false) {
+    const attrs = {
+        $: {
+            html: 1,
+            block: isInline ? 0 : 1,
+        },
+    };
+    for (const key in attribs) {
+        const value = attribs[key];
+        if (value === '') {
+            attrs[`:${key}`] = 'true';
+        }
+        else {
+            attrs[key] = value;
+        }
+    }
+    return attrs;
+}
+/**
+ * Parse a single inline HTML tag fragment (opening, closing, or void).
+ * Returns null if the content is not a recognisable HTML tag.
+ */
+export function parseInlineHtmlTag(html) {
+    const trimmed = html.trim();
+    if (!trimmed.startsWith('<'))
+        return null;
+    // Fast path: closing tag
+    const closeMatch = trimmed.match(/^<\/([a-z][a-z0-9]*)\s*>/i);
+    if (closeMatch) {
+        return { tag: closeMatch[1].toLowerCase(), attrs: {}, isVoid: false, isClose: true };
+    }
+    let info = null;
+    const parser = new Parser({
+        onopentag(name, attribs) {
+            info = {
+                tag: name,
+                attrs: attribsToComarkAttrs(attribs, true),
+                isVoid: VOID_ELEMENTS.has(name),
+                isClose: false,
+            };
+        },
+    }, { decodeEntities: false });
+    parser.write(trimmed);
+    parser.end();
+    return info;
+}
+/**
+ * Parse a full HTML string into ComarkNodes using htmlparser2.
+ * Handles nested elements, text, void elements, and comments.
+ */
+export function htmlToComarkNodes(html) {
+    const root = [];
+    const stack = [];
+    const parser = new Parser({
+        onopentag(name, attribs) {
+            const attrs = attribsToComarkAttrs(attribs);
+            if (VOID_ELEMENTS.has(name)) {
+                const node = [name, attrs];
+                if (stack.length > 0) {
+                    stack[stack.length - 1].children.push(node);
+                }
+                else {
+                    root.push(node);
+                }
+                return;
+            }
+            stack.push({ tag: name, attrs, children: [] });
+        },
+        ontext(text) {
+            const trimmed = text.trim();
+            if (!trimmed)
+                return;
+            if (stack.length > 0) {
+                stack[stack.length - 1].children.push(trimmed);
+            }
+            else {
+                root.push(trimmed);
+            }
+        },
+        onclosetag(name) {
+            if (VOID_ELEMENTS.has(name)) {
+                return;
+            }
+            // Find matching frame (handles mismatched tags gracefully)
+            let idx = stack.length - 1;
+            while (idx >= 0 && stack[idx].tag !== name) {
+                idx--;
+            }
+            if (idx >= 0) {
+                while (stack.length > idx) {
+                    const frame = stack.pop();
+                    const node = frame.children.length > 0
+                        ? [frame.tag, frame.attrs, ...frame.children]
+                        : [frame.tag, frame.attrs];
+                    if (stack.length > 0) {
+                        stack[stack.length - 1].children.push(node);
+                    }
+                    else {
+                        root.push(node);
+                    }
+                }
+            }
+        },
+        oncomment(data) {
+            const node = [null, {}, data];
+            if (stack.length > 0) {
+                stack[stack.length - 1].children.push(node);
+            }
+            else {
+                root.push(node);
+            }
+        },
+    }, { decodeEntities: true });
+    parser.write(html.trim());
+    parser.end();
+    return root;
+}

package/dist/internal/parse/incremental.d.ts

@@ -0,0 +1,12 @@
+import type { ComarkTree } from '../../types';
+/**
+ * Extracts reusable nodes from the last output tree
+ * @param markdown - The markdown to parse
+ * @param lastOutput - The last output tree
+ * @returns The reusable nodes and the remaining markdown
+ */
+export declare function extractReusableNodes(markdown: string, lastOutput: ComarkTree): {
+    remainingMarkdownStartLine: number;
+    reusedNodes: import("../..").ComarkNode[];
+    remainingMarkdown: string;
+};

package/dist/internal/parse/incremental.js

@@ -0,0 +1,39 @@
+/**
+ * Extracts reusable nodes from the last output tree
+ * @param markdown - The markdown to parse
+ * @param lastOutput - The last output tree
+ * @returns The reusable nodes and the remaining markdown
+ */
+export function extractReusableNodes(markdown, lastOutput) {
+    let lastValidNodeIndex = -1;
+    let i = lastOutput.nodes.length - 1;
+    let lastNodeIgnored = false;
+    while (i >= 0) {
+        const node = lastOutput.nodes[i];
+        if (node[1] && node[1].$?.line) {
+            if (lastNodeIgnored) {
+                lastValidNodeIndex = i;
+                break;
+            }
+            else {
+                lastNodeIgnored = true;
+            }
+        }
+        i--;
+    }
+    const lastNode = lastValidNodeIndex !== -1 ? lastOutput.nodes[lastValidNodeIndex] : null;
+    if (lastNode) {
+        const remainingMarkdownStartLine = lastNode[1].$?.line ?? 0;
+        return {
+            remainingMarkdownStartLine,
+            reusedNodes: lastOutput.nodes.slice(0, lastValidNodeIndex + 1),
+            remainingMarkdown: '\n' // Add back the new line character which will be remove by the slice and join
+                + markdown.split('\n').slice(remainingMarkdownStartLine + 1).join('\n') || '',
+        };
+    }
+    return {
+        remainingMarkdownStartLine: 0,
+        remainingMarkdown: markdown,
+        reusedNodes: [],
+    };
+}

package/dist/internal/parse/token-processor.d.ts

@@ -0,0 +1,9 @@
+import type { ComarkNode } from 'comark';
+/**
+ * Convert Markdown-It tokens to a Comark tree
+ */
+export declare function marmdownItTokensToComarkTree(tokens: any[], options?: {
+    startLine: number;
+    preservePositions: boolean;
+}): ComarkNode[];
+export declare function processInlineTokens(tokens: any[], inHeading?: boolean): ComarkNode[];