emdp 1.0.0

package/dist/esm/parser/blocks/code-block-fenced.js

@@ -0,0 +1,52 @@
+/**
+ * Parser for fenced code blocks with optional info strings.
+ */
+const BACKTICK_FENCE_OPEN_REGEX = /^( {0,3})(`{3,})([^`]*)$/;
+const TILDE_FENCE_OPEN_REGEX = /^( {0,3})(~{3,})(.*)$/;
+export function parseFenceOpen(line) {
+    let match = line.match(BACKTICK_FENCE_OPEN_REGEX);
+    if (!match) {
+        match = line.match(TILDE_FENCE_OPEN_REGEX);
+    }
+    if (!match)
+        return null;
+    const indent = match[1].length;
+    const fence = match[2];
+    const char = fence[0];
+    const length = fence.length;
+    const info = match[3].trim();
+    return { indent, char, length, info };
+}
+export function isFenceClose(line, fence) {
+    const trimmed = line.replace(/^( {0,3})/, '');
+    const closeRegex = new RegExp(`^${fence.char}{${fence.length},}[ \\t]*$`);
+    return closeRegex.test(trimmed);
+}
+export function isFencedCodeStart(line) {
+    return BACKTICK_FENCE_OPEN_REGEX.test(line) || TILDE_FENCE_OPEN_REGEX.test(line);
+}
+export function createFencedCodeBlock(info, lines, indent) {
+    const content = lines
+        .map(line => {
+        let removed = 0;
+        let i = 0;
+        while (i < line.length && removed < indent) {
+            if (line[i] === ' ') {
+                removed++;
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        return line.slice(i);
+    })
+        .join('\n');
+    const hasContent = lines.length > 0 && (lines.length > 1 || lines[0] !== '');
+    return {
+        type: 'code_block',
+        info,
+        literal: hasContent ? content + '\n' : '',
+        fenced: true,
+    };
+}

package/dist/esm/parser/blocks/code-block-indented.js

@@ -0,0 +1,42 @@
+/**
+ * Parser for indented code blocks.
+ */
+import { countLeadingSpaces } from '../utils.js';
+export function isIndentedCodeLine(line) {
+    if (line.trim() === '')
+        return false;
+    return countLeadingSpaces(line) >= 4;
+}
+export function removeIndentation(line, amount = 4) {
+    let removed = 0;
+    let i = 0;
+    while (i < line.length && removed < amount) {
+        if (line[i] === ' ') {
+            removed++;
+            i++;
+        }
+        else if (line[i] === '\t') {
+            const tabWidth = 4 - (removed % 4);
+            if (removed + tabWidth <= amount) {
+                removed += tabWidth;
+                i++;
+            }
+            else {
+                break;
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return line.slice(i);
+}
+export function createIndentedCodeBlock(lines) {
+    const content = lines.join('\n');
+    return {
+        type: 'code_block',
+        info: '',
+        literal: content + '\n',
+        fenced: false,
+    };
+}

package/dist/esm/parser/blocks/heading-atx.js

@@ -0,0 +1,24 @@
+/**
+ * Parser for ATX headings using leading # markers.
+ */
+const ATX_HEADING_REGEX = /^( {0,3})(#{1,6})([ \t].*|[ \t]*)$/;
+export function parseAtxHeading(line) {
+    const match = line.match(ATX_HEADING_REGEX);
+    if (!match)
+        return null;
+    const level = match[2].length;
+    let content = match[3];
+    content = content.replace(/[ \t]+#+[ \t]*$/, '');
+    content = content.trim();
+    return { level, content };
+}
+export function isAtxHeading(line) {
+    return ATX_HEADING_REGEX.test(line);
+}
+export function createHeadingNode(level) {
+    return {
+        type: 'heading',
+        level,
+        children: [],
+    };
+}

package/dist/esm/parser/blocks/heading-setext.js

@@ -0,0 +1,19 @@
+/**
+ * Parser for setext headings underlined with = or -.
+ */
+const SETEXT_HEADING_REGEX = /^( {0,3})(=+|-+)[ \t]*$/;
+export function parseSetextHeading(line) {
+    const match = line.match(SETEXT_HEADING_REGEX);
+    if (!match)
+        return null;
+    const char = match[2][0];
+    const level = char === '=' ? 1 : 2;
+    return { level: level };
+}
+export function isSetextHeadingUnderline(line) {
+    return SETEXT_HEADING_REGEX.test(line);
+}
+export function getSetextLevel(line) {
+    const result = parseSetextHeading(line);
+    return result?.level ?? null;
+}

package/dist/esm/parser/blocks/html-block.js

@@ -0,0 +1,77 @@
+/**
+ * Parser for raw HTML blocks defined by the CommonMark spec.
+ */
+const TYPE_6_TAGS = new Set([
+    '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'
+]);
+const TYPE_1_OPEN_REGEX = /^<(?:pre|script|style|textarea)(?:\s|>|$)/i;
+const TYPE_1_CLOSE_REGEX = /<\/(?:pre|script|style|textarea)>/i;
+const TYPE_2_OPEN_REGEX = /^<!--/;
+const TYPE_2_CLOSE_REGEX = /-->/;
+const TYPE_3_OPEN_REGEX = /^<\?/;
+const TYPE_3_CLOSE_REGEX = /\?>/;
+const TYPE_4_OPEN_REGEX = /^<![a-zA-Z]/;
+const TYPE_4_CLOSE_REGEX = />/;
+const TYPE_5_OPEN_REGEX = /^<!\[CDATA\[/i;
+const TYPE_5_CLOSE_REGEX = /\]\]>/;
+const TYPE_6_OPEN_REGEX = /^<\/?([a-zA-Z][a-zA-Z0-9-]*)(?:\s|\/?>|$)/i;
+const TYPE_7_OPEN_TAG_REGEX = /^<([a-zA-Z][a-zA-Z0-9-]*)(?:\s+[a-zA-Z_:][a-zA-Z0-9_.:-]*(?:\s*=\s*(?:[^\s"'=<>`]+|'[^']*'|"[^"]*"))?)*\s*\/?>\s*$/i;
+const TYPE_7_CLOSE_TAG_REGEX = /^<\/([a-zA-Z][a-zA-Z0-9-]*)\s*>\s*$/i;
+export function getHtmlBlockType(line, canInterruptParagraph) {
+    const trimmed = line.replace(/^ {0,3}/, '');
+    if (TYPE_1_OPEN_REGEX.test(trimmed))
+        return 1;
+    if (TYPE_2_OPEN_REGEX.test(trimmed))
+        return 2;
+    if (TYPE_3_OPEN_REGEX.test(trimmed))
+        return 3;
+    if (TYPE_4_OPEN_REGEX.test(trimmed))
+        return 4;
+    if (TYPE_5_OPEN_REGEX.test(trimmed))
+        return 5;
+    const type6Match = trimmed.match(TYPE_6_OPEN_REGEX);
+    if (type6Match && TYPE_6_TAGS.has(type6Match[1].toLowerCase())) {
+        return 6;
+    }
+    if (canInterruptParagraph) {
+        if (TYPE_7_OPEN_TAG_REGEX.test(trimmed) || TYPE_7_CLOSE_TAG_REGEX.test(trimmed)) {
+            return 7;
+        }
+    }
+    return null;
+}
+export function isHtmlBlockClose(line, type) {
+    switch (type) {
+        case 1:
+            return TYPE_1_CLOSE_REGEX.test(line);
+        case 2:
+            return TYPE_2_CLOSE_REGEX.test(line);
+        case 3:
+            return TYPE_3_CLOSE_REGEX.test(line);
+        case 4:
+            return TYPE_4_CLOSE_REGEX.test(line);
+        case 5:
+            return TYPE_5_CLOSE_REGEX.test(line);
+        case 6:
+        case 7:
+            return line.trim() === '';
+        default:
+            return false;
+    }
+}
+export function isHtmlBlockStart(line, canInterruptParagraph = true) {
+    return getHtmlBlockType(line, canInterruptParagraph) !== null;
+}
+export function createHtmlBlockNode(content) {
+    return {
+        type: 'html_block',
+        literal: content,
+    };
+}

package/dist/esm/parser/blocks/link-reference.js

@@ -0,0 +1,105 @@
+/**
+ * Parser for link reference definitions used by reference-style links.
+ */
+import { normalizeLabel, unescapeString, decodeHtmlEntities } from '../utils.js';
+const LINK_LABEL_REGEX = /^\[((?:[^\[\]\\]|\\.){0,999})\]/;
+const LINK_DESTINATION_ANGLE_REGEX = /^<([^<>\n\\]|\\.)*>/;
+const LINK_DESTINATION_BARE_REGEX = /^[^\s<\[\]]*(?:\([^\s<\[\]]*\)[^\s<\[\]]*)*[^\s<\[\]]*/;
+const LINK_TITLE_DOUBLE_REGEX = /^"((?:[^"\\]|\\[\s\S])*)"/;
+const LINK_TITLE_SINGLE_REGEX = /^'((?:[^'\\]|\\[\s\S])*)'/;
+const LINK_TITLE_PAREN_REGEX = /^\(((?:[^()\\]|\\[\s\S])*)\)/;
+export function parseLinkReferenceDefinition(text) {
+    let pos = 0;
+    const indentMatch = text.match(/^( {0,3})/);
+    if (indentMatch)
+        pos += indentMatch[1].length;
+    const labelMatch = text.slice(pos).match(LINK_LABEL_REGEX);
+    if (!labelMatch)
+        return null;
+    const rawLabel = labelMatch[1];
+    if (rawLabel.trim() === '')
+        return null;
+    pos += labelMatch[0].length;
+    if (text[pos] !== ':')
+        return null;
+    pos++;
+    const beforeDest = text.slice(pos).match(/^[ \t]*\n?[ \t]*/);
+    if (beforeDest)
+        pos += beforeDest[0].length;
+    let destination;
+    const angleMatch = text.slice(pos).match(LINK_DESTINATION_ANGLE_REGEX);
+    if (angleMatch) {
+        destination = angleMatch[0].slice(1, -1);
+        pos += angleMatch[0].length;
+    }
+    else {
+        const bareMatch = text.slice(pos).match(LINK_DESTINATION_BARE_REGEX);
+        if (!bareMatch || bareMatch[0] === '')
+            return null;
+        destination = bareMatch[0];
+        pos += bareMatch[0].length;
+    }
+    let title = '';
+    let titleFound = false;
+    const tryMatchTitle = (titlePos) => {
+        const remaining = text.slice(titlePos);
+        const doubleMatch = remaining.match(LINK_TITLE_DOUBLE_REGEX);
+        const singleMatch = remaining.match(LINK_TITLE_SINGLE_REGEX);
+        const parenMatch = remaining.match(LINK_TITLE_PAREN_REGEX);
+        const titleMatch = doubleMatch || singleMatch || parenMatch;
+        if (titleMatch) {
+            const afterTitlePos = titlePos + titleMatch[0].length;
+            const afterTitle = text.slice(afterTitlePos).match(/^[ \t]*(?:\n|$)/);
+            if (afterTitle) {
+                return { title: titleMatch[1], endPos: afterTitlePos + afterTitle[0].length };
+            }
+        }
+        return null;
+    };
+    const spaceBeforeTitle = text.slice(pos).match(/^[ \t]+/);
+    if (spaceBeforeTitle) {
+        const result = tryMatchTitle(pos + spaceBeforeTitle[0].length);
+        if (result) {
+            title = result.title;
+            pos = result.endPos;
+            titleFound = true;
+        }
+    }
+    if (!titleFound) {
+        const newlineBeforeTitle = text.slice(pos).match(/^[ \t]*\n[ \t]*/);
+        if (newlineBeforeTitle) {
+            const result = tryMatchTitle(pos + newlineBeforeTitle[0].length);
+            if (result) {
+                title = result.title;
+                pos = result.endPos;
+                titleFound = true;
+            }
+        }
+    }
+    if (!titleFound) {
+        const endAfterDest = text.slice(pos).match(/^[ \t]*(?:\n|$)/);
+        if (endAfterDest) {
+            pos += endAfterDest[0].length;
+            return {
+                label: normalizeLabel(unescapeString(rawLabel)),
+                definition: {
+                    destination: decodeHtmlEntities(unescapeString(destination)),
+                    title: '',
+                },
+                consumed: pos,
+            };
+        }
+        return null;
+    }
+    return {
+        label: normalizeLabel(unescapeString(rawLabel)),
+        definition: {
+            destination: decodeHtmlEntities(unescapeString(destination)),
+            title: decodeHtmlEntities(unescapeString(title)),
+        },
+        consumed: pos,
+    };
+}
+export function isLinkReferenceStart(line) {
+    return /^ {0,3}\[/.test(line);
+}

package/dist/esm/parser/blocks/list.js

@@ -0,0 +1,145 @@
+/**
+ * Parser for ordered and unordered lists with nesting and tight/loose detection.
+ */
+const BULLET_LIST_REGEX = /^( {0,3})([-+*])( +|\t|$)/;
+const ORDERED_LIST_REGEX = /^( {0,3})(\d{1,9})([.)])( +|\t|$)/;
+export function parseListMarker(line) {
+    const bulletMatch = line.match(BULLET_LIST_REGEX);
+    if (bulletMatch) {
+        const indentChars = bulletMatch[1].length;
+        const indent = indentChars;
+        const marker = bulletMatch[2];
+        const spacesAfter = bulletMatch[3];
+        let paddingChars = spacesAfter.length;
+        const columnAfterMarker = indent + 1;
+        let padding;
+        if (spacesAfter === '\t') {
+            padding = 4 - (columnAfterMarker % 4);
+        }
+        else if (spacesAfter === '') {
+            padding = 1;
+        }
+        else {
+            padding = spacesAfter.length;
+        }
+        let paddingToConsume = padding;
+        if (spacesAfter === '\t') {
+            paddingToConsume = 1;
+            paddingChars = 1;
+        }
+        else if (padding >= 5) {
+            paddingToConsume = 1;
+            paddingChars = 1;
+        }
+        const contentIndent = indent + 1 + paddingToConsume;
+        const contentCharIndex = indentChars + 1 + paddingChars;
+        return {
+            type: 'bullet',
+            indent,
+            indentChars,
+            marker,
+            bulletChar: marker,
+            padding: Math.min(paddingToConsume, 4),
+            paddingChars,
+            contentIndent,
+            contentCharIndex,
+        };
+    }
+    const orderedMatch = line.match(ORDERED_LIST_REGEX);
+    if (orderedMatch) {
+        const indentChars = orderedMatch[1].length;
+        const indent = indentChars;
+        const start = parseInt(orderedMatch[2], 10);
+        const delimiter = orderedMatch[3];
+        const marker = orderedMatch[2] + delimiter;
+        const spacesAfter = orderedMatch[4];
+        let paddingChars = spacesAfter.length;
+        const columnAfterMarker = indent + marker.length;
+        let padding;
+        if (spacesAfter === '\t') {
+            padding = 4 - (columnAfterMarker % 4);
+        }
+        else if (spacesAfter === '') {
+            padding = 1;
+        }
+        else {
+            padding = spacesAfter.length;
+        }
+        let paddingToConsume = padding;
+        if (spacesAfter === '\t') {
+            paddingToConsume = 1;
+            paddingChars = 1;
+        }
+        else if (padding >= 5) {
+            paddingToConsume = 1;
+            paddingChars = 1;
+        }
+        const contentIndent = indent + marker.length + paddingToConsume;
+        const contentCharIndex = indentChars + marker.length + paddingChars;
+        return {
+            type: 'ordered',
+            indent,
+            indentChars,
+            marker,
+            start,
+            delimiter,
+            padding: Math.min(paddingToConsume, 4),
+            paddingChars,
+            contentIndent,
+            contentCharIndex,
+        };
+    }
+    return null;
+}
+export function isListItemStart(line) {
+    return BULLET_LIST_REGEX.test(line) || ORDERED_LIST_REGEX.test(line);
+}
+export function isBulletListStart(line) {
+    return BULLET_LIST_REGEX.test(line);
+}
+export function isOrderedListStart(line) {
+    return ORDERED_LIST_REGEX.test(line);
+}
+export function canStartList(line, interruptingParagraph) {
+    if (!interruptingParagraph)
+        return isListItemStart(line);
+    const marker = parseListMarker(line);
+    if (!marker)
+        return false;
+    if (marker.type === 'ordered' && marker.start !== 1) {
+        return false;
+    }
+    const content = line.slice(marker.indent + marker.marker.length + marker.padding);
+    if (content.trim() === '') {
+        return false;
+    }
+    return true;
+}
+export function createListNode(marker) {
+    return {
+        type: 'list',
+        listType: marker.type,
+        start: marker.start ?? 1,
+        tight: true,
+        delimiter: marker.delimiter ?? null,
+        bulletChar: marker.bulletChar ?? null,
+        children: [],
+    };
+}
+export function createListItemNode() {
+    return {
+        type: 'list_item',
+        children: [],
+    };
+}
+export function listsMatch(a, b) {
+    if (a.type !== b.type)
+        return false;
+    if (a.type === 'bullet' && b.type === 'bullet') {
+        return a.bulletChar === b.bulletChar;
+    }
+    if (a.type === 'ordered' && b.type === 'ordered') {
+        return a.delimiter === b.delimiter;
+    }
+    return false;
+}

package/dist/esm/parser/blocks/paragraph.js

@@ -0,0 +1,15 @@
+/**
+ * Parser for paragraph blocks as the default block type.
+ */
+export function createParagraphNode() {
+    return {
+        type: 'paragraph',
+        children: [],
+    };
+}
+export function isParagraphContinuation(line) {
+    return line.trim() !== '';
+}
+export function trimParagraphLine(line) {
+    return line.replace(/^ {0,3}/, '').replace(/[ \t]+$/, '');
+}

package/dist/esm/parser/blocks/table.js

@@ -0,0 +1,152 @@
+/**
+ * Parser for GFM tables built from pipe-delimited rows.
+ */
+export 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;
+}
+export 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;
+}
+export 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;
+}
+export function couldBeTableHeader(line) {
+    return isTableRow(line);
+}
+export 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;
+}
+export function createTableCellNode(align, isHeader, children = []) {
+    return {
+        type: 'table_cell',
+        children,
+        align,
+        isHeader,
+    };
+}
+export function createTableRowNode(isHeader, cells = []) {
+    return {
+        type: 'table_row',
+        children: cells,
+        isHeader,
+    };
+}
+export function createTableNode(alignments) {
+    return {
+        type: 'table',
+        alignments,
+        children: [],
+    };
+}
+export 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/esm/parser/blocks/task-list.js

@@ -0,0 +1,61 @@
+/**
+ * Parser for GFM task list items that recognize [ ] and [x] markers.
+ */
+const TASK_LIST_MARKER = /^\[([ xX])\](?=\s)/;
+export 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,
+    };
+}
+export 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();
+                }
+            }
+        }
+    }
+}
+export 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);
+        }
+    }
+}