emdp 1.0.0

package/dist/esm/parser/inlines/link.js

@@ -0,0 +1,156 @@
+/**
+ * Parser for inline links and images, including destinations, titles, and reference labels.
+ */
+import { normalizeLabel, unescapeString, decodeHtmlEntities } from '../utils.js';
+const LINK_DESTINATION_ANGLE_REGEX = /^<([^<>\n\\]|\\.)*>/;
+const LINK_DESTINATION_BARE_REGEX = /^[^\s\x00-\x1f]*?(?:\([^\s\x00-\x1f]*?\)[^\s\x00-\x1f]*?)*[^\s\x00-\x1f)]/;
+const LINK_TITLE_REGEX = /^(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|\(([^()\\]*(?:\\.[^()\\]*)*)\))/;
+export function parseLinkDestination(text) {
+    if (text[0] === '<') {
+        const match = text.match(LINK_DESTINATION_ANGLE_REGEX);
+        if (match) {
+            return {
+                destination: decodeHtmlEntities(unescapeString(match[0].slice(1, -1))),
+                length: match[0].length,
+            };
+        }
+        return null;
+    }
+    let parenDepth = 0;
+    let i = 0;
+    while (i < text.length) {
+        const char = text[i];
+        if (char === '\\' && i + 1 < text.length) {
+            const nextChar = text[i + 1];
+            if (nextChar === ' ' || nextChar === '\t' || nextChar === '\n' || nextChar === '\r') {
+                return null;
+            }
+            i += 2;
+            continue;
+        }
+        if (char === '(') {
+            parenDepth++;
+        }
+        else if (char === ')') {
+            if (parenDepth === 0)
+                break;
+            parenDepth--;
+        }
+        else if (char === ' ' || char === '\t' || char === '\n' || char === '\r' || char.charCodeAt(0) < 0x20) {
+            break;
+        }
+        i++;
+    }
+    if (i === 0)
+        return null;
+    return {
+        destination: decodeHtmlEntities(unescapeString(text.slice(0, i))),
+        length: i,
+    };
+}
+export function parseLinkTitle(text) {
+    const match = text.match(LINK_TITLE_REGEX);
+    if (!match)
+        return null;
+    const title = match[1] ?? match[2] ?? match[3] ?? '';
+    return {
+        title: decodeHtmlEntities(unescapeString(title)),
+        length: match[0].length,
+    };
+}
+export function parseInlineLink(text, pos) {
+    if (text[pos] !== '(')
+        return null;
+    let i = pos + 1;
+    while (i < text.length && /[ \t\n]/.test(text[i]))
+        i++;
+    if (text[i] === ')') {
+        return { destination: '', title: '', length: i - pos + 1 };
+    }
+    const destResult = parseLinkDestination(text.slice(i));
+    if (!destResult)
+        return null;
+    const destination = destResult.destination;
+    i += destResult.length;
+    while (i < text.length && /[ \t]/.test(text[i]))
+        i++;
+    let title = '';
+    if (text[i] === '\n') {
+        i++;
+        while (i < text.length && /[ \t]/.test(text[i]))
+            i++;
+    }
+    if (text[i] === '"' || text[i] === "'" || text[i] === '(') {
+        const titleResult = parseLinkTitle(text.slice(i));
+        if (titleResult) {
+            title = titleResult.title;
+            i += titleResult.length;
+        }
+    }
+    while (i < text.length && /[ \t\n]/.test(text[i]))
+        i++;
+    if (text[i] !== ')')
+        return null;
+    return { destination, title, length: i - pos + 1 };
+}
+export function parseLinkLabel(text, pos) {
+    if (text[pos] !== '[')
+        return null;
+    let i = pos + 1;
+    let depth = 1;
+    let label = '';
+    while (i < text.length && depth > 0) {
+        const char = text[i];
+        if (char === '\\' && i + 1 < text.length) {
+            const next = text[i + 1];
+            if (next === '[' || next === ']' || next === '\\') {
+                label += next;
+                i += 2;
+                continue;
+            }
+            label += '\\';
+            i++;
+            continue;
+        }
+        if (char === '[') {
+            return null;
+        }
+        if (char === ']') {
+            depth--;
+            if (depth === 0)
+                break;
+        }
+        label += char;
+        i++;
+    }
+    if (depth !== 0)
+        return null;
+    if (label.length > 999)
+        return null;
+    if (label.trim() === '') {
+        return { label: '', length: i - pos + 1 };
+    }
+    return { label: normalizeLabel(label), length: i - pos + 1 };
+}
+export function createLinkNode(destination, title) {
+    return {
+        type: 'link',
+        destination,
+        title,
+        children: [],
+    };
+}
+export function createImageNode(destination, title, alt) {
+    return {
+        type: 'image',
+        destination,
+        title,
+        alt,
+    };
+}
+export function isLinkStart(text, pos) {
+    return text[pos] === '[';
+}
+export function isImageStart(text, pos) {
+    return text[pos] === '!' && text[pos + 1] === '[';
+}

package/dist/esm/parser/inlines/soft-break.js

@@ -0,0 +1,14 @@
+/**
+ * Parser for soft line breaks created by single newlines.
+ */
+export function parseSoftBreak(text, pos) {
+    if (text[pos] !== '\n')
+        return null;
+    return {
+        node: { type: 'softbreak' },
+        length: 1,
+    };
+}
+export function isSoftBreak(text, pos) {
+    return text[pos] === '\n';
+}

package/dist/esm/parser/inlines/strikethrough.js

@@ -0,0 +1,42 @@
+/**
+ * Parser for GFM strikethrough using ~ delimiters.
+ */
+export function parseStrikethroughDelimiter(text, pos) {
+    if (text[pos] !== '~')
+        return null;
+    let length = 0;
+    let i = pos;
+    while (i < text.length && text[i] === '~') {
+        length++;
+        i++;
+    }
+    if (length > 2)
+        return null;
+    const charBefore = pos > 0 ? text[pos - 1] : '\n';
+    const charAfter = i < text.length ? text[i] : '\n';
+    const isWhitespace = (c) => /\s/.test(c) || c === '\n';
+    const beforeIsWhitespace = isWhitespace(charBefore);
+    const afterIsWhitespace = isWhitespace(charAfter);
+    const canOpen = !afterIsWhitespace;
+    const canClose = !beforeIsWhitespace;
+    return {
+        char: '~',
+        length,
+        canOpen,
+        canClose,
+        position: pos,
+        origLength: length,
+    };
+}
+export function isStrikethroughDelimiter(text, pos) {
+    return text[pos] === '~';
+}
+export function createStrikethroughNode(children = []) {
+    return {
+        type: 'strikethrough',
+        children,
+    };
+}
+export function canStrikethroughDelimitersMatch(opener, closer) {
+    return opener.length === closer.length;
+}

package/dist/esm/parser/inlines/text.js

@@ -0,0 +1,16 @@
+/**
+ * Text node factories for literal inline content.
+ */
+export function createTextNode(literal, noDelim = false) {
+    return {
+        type: 'text',
+        literal,
+        ...(noDelim ? { noDelim: true } : {}),
+    };
+}
+export function mergeTextNodes(nodes) {
+    return {
+        type: 'text',
+        literal: nodes.map(n => n.literal).join(''),
+    };
+}

package/dist/esm/parser/renderer.js

@@ -0,0 +1,341 @@
+/**
+ * HTML renderer that converts a Markdown AST into HTML with configurable list, URL safety,
+ * and soft-break handling.
+ */
+import { escapeHtml } from './utils.js';
+function encodeUrl(url) {
+    let result = '';
+    let i = 0;
+    while (i < url.length) {
+        const char = url[i];
+        const code = char.charCodeAt(0);
+        if (char === '%' && i + 2 < url.length && /^[0-9a-fA-F]{2}$/.test(url.slice(i + 1, i + 3))) {
+            result += url.slice(i, i + 3).toUpperCase();
+            i += 3;
+        }
+        else if (/[A-Za-z0-9\-._~:/?#@!$&'()*+,;=]/.test(char)) {
+            result += char;
+            i++;
+        }
+        else if (code >= 0xD800 && code <= 0xDBFF && i + 1 < url.length) {
+            const fullChar = url.slice(i, i + 2);
+            const encoded = encodeURIComponent(fullChar);
+            result += encoded;
+            i += 2;
+        }
+        else {
+            const encoded = encodeURIComponent(char);
+            result += encoded;
+            i++;
+        }
+    }
+    return result;
+}
+export class HtmlRenderer {
+    options;
+    constructor(options = {}) {
+        this.options = {
+            softbreak: '\n',
+            safe: false,
+            ...options,
+        };
+    }
+    render(document) {
+        const content = this.renderBlocks(document.children);
+        return content ? content + '\n' : '';
+    }
+    renderBlocks(blocks, tight = false) {
+        return blocks.map(block => this.renderBlock(block, tight)).join('\n');
+    }
+    renderBlock(block, tight = false) {
+        switch (block.type) {
+            case 'paragraph':
+                return this.renderParagraph(block, tight);
+            case 'heading':
+                return this.renderHeading(block);
+            case 'thematic_break':
+                return this.renderThematicBreak(block);
+            case 'code_block':
+                return this.renderCodeBlock(block);
+            case 'blockquote':
+                return this.renderBlockquote(block);
+            case 'list':
+                return this.renderList(block);
+            case 'list_item':
+                return this.renderListItem(block);
+            case 'html_block':
+                return this.renderHtmlBlock(block);
+            default:
+                return '';
+        }
+    }
+    renderParagraph(node, tight = false) {
+        const content = this.renderInlines(node.children);
+        if (tight) {
+            return content;
+        }
+        return `<p>${content}</p>`;
+    }
+    renderHeading(node) {
+        const content = this.renderInlines(node.children);
+        return `<h${node.level}>${content}</h${node.level}>`;
+    }
+    renderThematicBreak(_node) {
+        return '<hr />';
+    }
+    renderCodeBlock(node) {
+        const escaped = escapeHtml(node.literal);
+        if (node.info) {
+            const lang = escapeHtml(node.info.split(/\s+/)[0]);
+            return `<pre><code class="language-${lang}">${escaped}</code></pre>`;
+        }
+        return `<pre><code>${escaped}</code></pre>`;
+    }
+    renderBlockquote(node) {
+        const content = this.renderBlocks(node.children);
+        if (content) {
+            return `<blockquote>\n${content}\n</blockquote>`;
+        }
+        return '<blockquote>\n</blockquote>';
+    }
+    renderList(node) {
+        const tag = node.listType === 'bullet' ? 'ul' : 'ol';
+        const startAttr = node.listType === 'ordered' && node.start !== 1 ? ` start="${node.start}"` : '';
+        const items = node.children.map(item => this.renderListItem(item, node.tight)).join('\n');
+        return `<${tag}${startAttr}>\n${items}\n</${tag}>`;
+    }
+    renderListItem(node, tight = false) {
+        if (node.children.length === 0) {
+            return '<li></li>';
+        }
+        const content = this.renderBlocks(node.children, tight);
+        if (tight && node.children.length === 1 && node.children[0].type === 'paragraph') {
+            return `<li>${content}</li>`;
+        }
+        if (content) {
+            return `<li>\n${content}\n</li>`;
+        }
+        return '<li></li>';
+    }
+    renderHtmlBlock(node) {
+        if (this.options.safe) {
+            return '<!-- raw HTML omitted -->';
+        }
+        return node.literal.replace(/\n$/, '');
+    }
+    renderInlines(inlines) {
+        if (this.options.smart) {
+            return this.renderInlinesSmart(inlines);
+        }
+        return inlines.map(inline => this.renderInline(inline)).join('');
+    }
+    renderInline(inline) {
+        switch (inline.type) {
+            case 'text':
+                return this.renderText(inline);
+            case 'softbreak':
+                return this.renderSoftbreak(inline);
+            case 'hardbreak':
+                return this.renderHardbreak(inline);
+            case 'code_span':
+                return this.renderCodeSpan(inline);
+            case 'emphasis':
+                return this.renderEmphasis(inline);
+            case 'strong':
+                return this.renderStrong(inline);
+            case 'link':
+                return this.renderLink(inline);
+            case 'image':
+                return this.renderImage(inline);
+            case 'html_inline':
+                return this.renderHtmlInline(inline);
+            default:
+                return '';
+        }
+    }
+    renderText(node) {
+        return escapeHtml(node.literal);
+    }
+    renderSoftbreak(_node) {
+        return this.options.softbreak;
+    }
+    renderHardbreak(_node) {
+        return '<br />\n';
+    }
+    renderCodeSpan(node) {
+        return `<code>${escapeHtml(node.literal)}</code>`;
+    }
+    renderEmphasis(node) {
+        const content = this.renderInlines(node.children);
+        return `<em>${content}</em>`;
+    }
+    renderStrong(node) {
+        const content = this.renderInlines(node.children);
+        return `<strong>${content}</strong>`;
+    }
+    renderLink(node) {
+        if (this.options.safe && /^javascript:/i.test(node.destination)) {
+            return this.renderInlines(node.children);
+        }
+        const href = escapeHtml(encodeUrl(node.destination));
+        const title = node.title ? ` title="${escapeHtml(node.title)}"` : '';
+        const content = this.renderInlines(node.children);
+        return `<a href="${href}"${title}>${content}</a>`;
+    }
+    renderImage(node) {
+        if (this.options.safe && /^javascript:/i.test(node.destination)) {
+            return escapeHtml(node.alt);
+        }
+        const src = escapeHtml(encodeUrl(node.destination));
+        const alt = escapeHtml(node.alt);
+        const title = node.title ? ` title="${escapeHtml(node.title)}"` : '';
+        return `<img src="${src}" alt="${alt}"${title} />`;
+    }
+    renderHtmlInline(node) {
+        if (this.options.safe) {
+            return '<!-- raw HTML omitted -->';
+        }
+        return node.literal;
+    }
+    renderInlinesSmart(inlines) {
+        const tokens = [];
+        const nodeTokens = new Map();
+        const pushTextTokens = (node) => {
+            const indices = [];
+            for (let i = 0; i < node.literal.length; i++) {
+                const idx = tokens.length;
+                tokens.push({
+                    char: node.literal[i],
+                    node,
+                    nodeOffset: i,
+                    noSmart: !!node.noSmart,
+                });
+                indices.push(idx);
+            }
+            nodeTokens.set(node, indices);
+        };
+        for (const inline of inlines) {
+            if (inline.type === 'text') {
+                pushTextTokens(inline);
+            }
+            else if (inline.type === 'softbreak' || inline.type === 'hardbreak') {
+                tokens.push({ char: '\n', node: null, nodeOffset: 0, noSmart: false });
+            }
+            else {
+                tokens.push({ char: 'A', node: null, nodeOffset: 0, noSmart: false });
+            }
+        }
+        const replacements = new Map();
+        const doubleStack = [];
+        const singleStack = [];
+        const isWhitespace = (c) => /\s/.test(c);
+        const isPunctuation = (c) => /[\p{P}\p{S}]/u.test(c);
+        const isAlphaNum = (c) => /[A-Za-z0-9]/.test(c);
+        for (let i = 0; i < tokens.length; i++) {
+            const token = tokens[i];
+            if (token.noSmart)
+                continue;
+            if (token.char !== '"' && token.char !== "'")
+                continue;
+            const before = i > 0 ? tokens[i - 1].char : '\n';
+            const after = i + 1 < tokens.length ? tokens[i + 1].char : '\n';
+            const beforeIsWhitespace = isWhitespace(before);
+            const afterIsWhitespace = isWhitespace(after);
+            const beforeIsPunct = isPunctuation(before);
+            const afterIsPunct = isPunctuation(after);
+            let leftFlanking = !afterIsWhitespace &&
+                (!afterIsPunct || beforeIsWhitespace || beforeIsPunct);
+            let rightFlanking = !beforeIsWhitespace &&
+                (!beforeIsPunct || afterIsWhitespace || afterIsPunct);
+            if (before === ')' || before === ']') {
+                leftFlanking = false;
+            }
+            if (token.char === "'") {
+                if (isAlphaNum(before) && isAlphaNum(after)) {
+                    replacements.set(i, '’');
+                    continue;
+                }
+                if ((before === ')' || before === ']') && isAlphaNum(after)) {
+                    replacements.set(i, '’');
+                    continue;
+                }
+                if (rightFlanking && singleStack.length > 0) {
+                    const opener = singleStack.pop();
+                    replacements.set(opener, '‘');
+                    replacements.set(i, '’');
+                    continue;
+                }
+                if (leftFlanking) {
+                    singleStack.push(i);
+                    continue;
+                }
+                replacements.set(i, '’');
+            }
+            else {
+                if (rightFlanking && doubleStack.length > 0) {
+                    const opener = doubleStack.pop();
+                    replacements.set(opener, '“');
+                    replacements.set(i, '”');
+                    continue;
+                }
+                if (leftFlanking) {
+                    doubleStack.push(i);
+                    continue;
+                }
+                replacements.set(i, '“');
+            }
+        }
+        for (const idx of doubleStack) {
+            replacements.set(idx, '“');
+        }
+        for (const idx of singleStack) {
+            replacements.set(idx, '’');
+        }
+        const renderTextNodes = new Map();
+        for (const [node, indices] of nodeTokens.entries()) {
+            if (node.noSmart) {
+                renderTextNodes.set(node, escapeHtml(node.literal));
+                continue;
+            }
+            let result = '';
+            for (let i = 0; i < indices.length; i++) {
+                const tokenIndex = indices[i];
+                const token = tokens[tokenIndex];
+                const replacement = replacements.get(tokenIndex);
+                result += replacement ?? token.char;
+            }
+            result = this.applyDashesAndEllipses(result);
+            renderTextNodes.set(node, escapeHtml(result));
+        }
+        return inlines.map(inline => {
+            if (inline.type === 'text') {
+                return renderTextNodes.get(inline) ?? '';
+            }
+            return this.renderInline(inline);
+        }).join('');
+    }
+    applyDashesAndEllipses(text) {
+        let result = text.replace(/\.{3}/g, '…');
+        result = result.replace(/-{2,}/g, (match) => {
+            const count = match.length;
+            if (count % 3 === 0) {
+                return '—'.repeat(count / 3);
+            }
+            if (count % 2 === 0) {
+                return '–'.repeat(count / 2);
+            }
+            let emCount = Math.floor(count / 3);
+            const remainder = count % 3;
+            let enCount = 0;
+            if (remainder === 1) {
+                emCount = Math.max(0, emCount - 1);
+                enCount = 2;
+            }
+            else if (remainder === 2) {
+                enCount = 1;
+            }
+            return '—'.repeat(emCount) + '–'.repeat(enCount);
+        });
+        return result;
+    }
+}

package/dist/esm/parser/types.js

@@ -0,0 +1,4 @@
+/**
+ * Type definitions for the Markdown AST nodes and parser/render options.
+ */
+export {};