emdp 1.0.0

package/dist/parser/blocks/table.js

@@ -0,0 +1,163 @@
+"use strict";
+/**
+ * Parser for GFM tables built from pipe-delimited rows.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDelimiterRow = parseDelimiterRow;
+exports.splitTableRow = splitTableRow;
+exports.isTableRow = isTableRow;
+exports.couldBeTableHeader = couldBeTableHeader;
+exports.isTableStart = isTableStart;
+exports.createTableCellNode = createTableCellNode;
+exports.createTableRowNode = createTableRowNode;
+exports.createTableNode = createTableNode;
+exports.parseTableRowCells = parseTableRowCells;
+function parseDelimiterRow(line) {
+    const trimmed = line.trim();
+    let cells = splitTableRow(trimmed);
+    if (cells.length === 0)
+        return null;
+    const alignments = [];
+    for (const cell of cells) {
+        const content = cell.trim();
+        if (!/^:?-+:?$/.test(content)) {
+            return null;
+        }
+        const hasLeftColon = content.startsWith(':');
+        const hasRightColon = content.endsWith(':');
+        if (hasLeftColon && hasRightColon) {
+            alignments.push('center');
+        }
+        else if (hasRightColon) {
+            alignments.push('right');
+        }
+        else if (hasLeftColon) {
+            alignments.push('left');
+        }
+        else {
+            alignments.push(null);
+        }
+    }
+    return alignments;
+}
+function splitTableRow(line) {
+    const cells = [];
+    let current = '';
+    let i = 0;
+    let inBackticks = false;
+    let backtickCount = 0;
+    let trimmed = line.trim();
+    if (trimmed.startsWith('|')) {
+        trimmed = trimmed.slice(1);
+    }
+    if (trimmed.endsWith('|') && !trimmed.endsWith('\\|')) {
+        trimmed = trimmed.slice(0, -1);
+    }
+    while (i < trimmed.length) {
+        const char = trimmed[i];
+        if (char === '`') {
+            if (!inBackticks) {
+                inBackticks = true;
+                backtickCount = 1;
+                let j = i + 1;
+                while (j < trimmed.length && trimmed[j] === '`') {
+                    backtickCount++;
+                    j++;
+                }
+                current += trimmed.slice(i, j);
+                i = j;
+                continue;
+            }
+            else {
+                let closeCount = 1;
+                let j = i + 1;
+                while (j < trimmed.length && trimmed[j] === '`') {
+                    closeCount++;
+                    j++;
+                }
+                if (closeCount === backtickCount) {
+                    inBackticks = false;
+                }
+                current += trimmed.slice(i, j);
+                i = j;
+                continue;
+            }
+        }
+        if (char === '\\' && i + 1 < trimmed.length && trimmed[i + 1] === '|') {
+            current += '|';
+            i += 2;
+            continue;
+        }
+        if (char === '|' && !inBackticks) {
+            cells.push(current);
+            current = '';
+            i++;
+            continue;
+        }
+        current += char;
+        i++;
+    }
+    cells.push(current);
+    return cells;
+}
+function isTableRow(line) {
+    const trimmed = line.trim();
+    for (let i = 0; i < trimmed.length; i++) {
+        if (trimmed[i] === '|') {
+            if (i === 0 || trimmed[i - 1] !== '\\') {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+function couldBeTableHeader(line) {
+    return isTableRow(line);
+}
+function isTableStart(headerLine, delimiterLine) {
+    if (!isTableRow(headerLine))
+        return null;
+    const headerCells = splitTableRow(headerLine);
+    const hasContent = headerCells.some(cell => cell.trim() !== '');
+    if (!hasContent)
+        return null;
+    const alignments = parseDelimiterRow(delimiterLine);
+    if (!alignments)
+        return null;
+    if (headerCells.length !== alignments.length)
+        return null;
+    return alignments;
+}
+function createTableCellNode(align, isHeader, children = []) {
+    return {
+        type: 'table_cell',
+        children,
+        align,
+        isHeader,
+    };
+}
+function createTableRowNode(isHeader, cells = []) {
+    return {
+        type: 'table_row',
+        children: cells,
+        isHeader,
+    };
+}
+function createTableNode(alignments) {
+    return {
+        type: 'table',
+        alignments,
+        children: [],
+    };
+}
+function parseTableRowCells(line, alignments, isHeader) {
+    const cellContents = splitTableRow(line);
+    const cells = [];
+    for (let i = 0; i < alignments.length; i++) {
+        const content = cellContents[i]?.trim() ?? '';
+        const cell = createTableCellNode(alignments[i], isHeader);
+        cell.rawContent = content;
+        cells.push(cell);
+    }
+    return cells;
+}

package/dist/parser/blocks/task-list.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Parser for GFM task list items that recognize [ ] and [x] markers.
+ */
+import type { ListItemNode } from '../types.js';
+export declare function parseTaskListMarker(text: string): {
+    checked: boolean;
+    length: number;
+} | null;
+export declare function processTaskListItem(item: ListItemNode): void;
+export declare function processTaskLists(blocks: any[]): void;

package/dist/parser/blocks/task-list.js

@@ -0,0 +1,66 @@
+"use strict";
+/**
+ * Parser for GFM task list items that recognize [ ] and [x] markers.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseTaskListMarker = parseTaskListMarker;
+exports.processTaskListItem = processTaskListItem;
+exports.processTaskLists = processTaskLists;
+const TASK_LIST_MARKER = /^\[([ xX])\](?=\s)/;
+function parseTaskListMarker(text) {
+    const match = text.match(TASK_LIST_MARKER);
+    if (!match)
+        return null;
+    const char = match[1];
+    const checked = char === 'x' || char === 'X';
+    return {
+        checked,
+        length: 3,
+    };
+}
+function processTaskListItem(item) {
+    if (item.children.length === 0)
+        return;
+    const firstChild = item.children[0];
+    if (firstChild.type !== 'paragraph')
+        return;
+    const para = firstChild;
+    const rawContent = para.rawContent;
+    if (typeof rawContent === 'string') {
+        const result = parseTaskListMarker(rawContent);
+        if (result) {
+            item.checked = result.checked;
+            para.rawContent = rawContent.slice(result.length).replace(/^\s/, '');
+        }
+        return;
+    }
+    if (para.children && para.children.length > 0) {
+        const firstInline = para.children[0];
+        if (firstInline.type === 'text') {
+            const textNode = firstInline;
+            const result = parseTaskListMarker(textNode.literal);
+            if (result) {
+                item.checked = result.checked;
+                textNode.literal = textNode.literal.slice(result.length).replace(/^\s/, '');
+                if (textNode.literal === '') {
+                    para.children.shift();
+                }
+            }
+        }
+    }
+}
+function processTaskLists(blocks) {
+    for (const block of blocks) {
+        if (block.type === 'list') {
+            for (const item of block.children) {
+                processTaskListItem(item);
+                if (item.children) {
+                    processTaskLists(item.children);
+                }
+            }
+        }
+        else if (block.type === 'blockquote' && block.children) {
+            processTaskLists(block.children);
+        }
+    }
+}

package/dist/parser/blocks/thematic-break.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Parser for thematic breaks (horizontal rules).
+ */
+import type { ThematicBreakNode } from '../types.js';
+export declare function parseThematicBreak(line: string): ThematicBreakNode | null;
+export declare function isThematicBreak(line: string): boolean;

package/dist/parser/blocks/thematic-break.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Parser for thematic breaks (horizontal rules).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseThematicBreak = parseThematicBreak;
+exports.isThematicBreak = isThematicBreak;
+const THEMATIC_BREAK_REGEX = /^( {0,3})([-*_])(?:[ \t]*\2){2,}[ \t]*$/;
+function parseThematicBreak(line) {
+    if (THEMATIC_BREAK_REGEX.test(line)) {
+        return { type: 'thematic_break' };
+    }
+    return null;
+}
+function isThematicBreak(line) {
+    return THEMATIC_BREAK_REGEX.test(line);
+}

package/dist/parser/entities.d.ts

@@ -0,0 +1,4 @@
+/**
+ * HTML named character reference map used to decode entities in Markdown content.
+ */
+export declare const HTML_ENTITIES: Record<string, string>;