emdp 1.0.0

package/dist/parser/renderer.js

@@ -0,0 +1,345 @@
+"use strict";
+/**
+ * HTML renderer that converts a Markdown AST into HTML with configurable list, URL safety,
+ * and soft-break handling.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.HtmlRenderer = void 0;
+const utils_js_1 = require("./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;
+}
+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 = (0, utils_js_1.escapeHtml)(node.literal);
+        if (node.info) {
+            const lang = (0, utils_js_1.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 (0, utils_js_1.escapeHtml)(node.literal);
+    }
+    renderSoftbreak(_node) {
+        return this.options.softbreak;
+    }
+    renderHardbreak(_node) {
+        return '<br />\n';
+    }
+    renderCodeSpan(node) {
+        return `<code>${(0, utils_js_1.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 = (0, utils_js_1.escapeHtml)(encodeUrl(node.destination));
+        const title = node.title ? ` title="${(0, utils_js_1.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 (0, utils_js_1.escapeHtml)(node.alt);
+        }
+        const src = (0, utils_js_1.escapeHtml)(encodeUrl(node.destination));
+        const alt = (0, utils_js_1.escapeHtml)(node.alt);
+        const title = node.title ? ` title="${(0, utils_js_1.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, (0, utils_js_1.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, (0, utils_js_1.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;
+    }
+}
+exports.HtmlRenderer = HtmlRenderer;

package/dist/parser/types.d.ts

@@ -0,0 +1,152 @@
+/**
+ * Type definitions for the Markdown AST nodes and parser/render options.
+ */
+export type BlockType = 'document' | 'paragraph' | 'heading' | 'thematic_break' | 'code_block' | 'blockquote' | 'list' | 'list_item' | 'html_block' | 'link_reference_definition' | 'table';
+export type InlineType = 'text' | 'softbreak' | 'hardbreak' | 'code_span' | 'emphasis' | 'strong' | 'strikethrough' | 'footnote_ref' | 'link' | 'image' | 'html_inline';
+export interface Position {
+    line: number;
+    column: number;
+    offset: number;
+}
+export interface SourceLocation {
+    start: Position;
+    end: Position;
+}
+export interface BaseNode {
+    type: string;
+    sourcepos?: SourceLocation;
+}
+export interface DocumentNode extends BaseNode {
+    type: 'document';
+    children: BlockNode[];
+    footnoteDefinitions?: Map<string, FootnoteDefinition>;
+}
+export interface ParagraphNode extends BaseNode {
+    type: 'paragraph';
+    children: InlineNode[];
+}
+export interface HeadingNode extends BaseNode {
+    type: 'heading';
+    level: 1 | 2 | 3 | 4 | 5 | 6;
+    children: InlineNode[];
+}
+export interface ThematicBreakNode extends BaseNode {
+    type: 'thematic_break';
+}
+export interface CodeBlockNode extends BaseNode {
+    type: 'code_block';
+    info: string;
+    literal: string;
+    fenced: boolean;
+}
+export interface BlockquoteNode extends BaseNode {
+    type: 'blockquote';
+    children: BlockNode[];
+}
+export interface ListNode extends BaseNode {
+    type: 'list';
+    listType: 'bullet' | 'ordered';
+    start: number;
+    tight: boolean;
+    delimiter: '.' | ')' | null;
+    bulletChar: '-' | '+' | '*' | null;
+    children: ListItemNode[];
+}
+export interface ListItemNode extends BaseNode {
+    type: 'list_item';
+    children: BlockNode[];
+    checked?: boolean | null;
+}
+export interface HtmlBlockNode extends BaseNode {
+    type: 'html_block';
+    literal: string;
+}
+export type TableAlignment = 'left' | 'center' | 'right' | null;
+export interface TableCellNode extends BaseNode {
+    type: 'table_cell';
+    children: InlineNode[];
+    align: TableAlignment;
+    isHeader: boolean;
+}
+export interface TableRowNode extends BaseNode {
+    type: 'table_row';
+    children: TableCellNode[];
+    isHeader: boolean;
+}
+export interface TableNode extends BaseNode {
+    type: 'table';
+    alignments: TableAlignment[];
+    children: TableRowNode[];
+}
+export interface LinkReferenceDefinition {
+    destination: string;
+    title: string;
+}
+export type BlockNode = ParagraphNode | HeadingNode | ThematicBreakNode | CodeBlockNode | BlockquoteNode | ListNode | ListItemNode | HtmlBlockNode | TableNode;
+export interface TextNode extends BaseNode {
+    type: 'text';
+    literal: string;
+    noDelim?: boolean;
+    noSmart?: boolean;
+}
+export interface SoftbreakNode extends BaseNode {
+    type: 'softbreak';
+}
+export interface HardbreakNode extends BaseNode {
+    type: 'hardbreak';
+}
+export interface CodeSpanNode extends BaseNode {
+    type: 'code_span';
+    literal: string;
+}
+export interface EmphasisNode extends BaseNode {
+    type: 'emphasis';
+    children: InlineNode[];
+}
+export interface StrongNode extends BaseNode {
+    type: 'strong';
+    children: InlineNode[];
+}
+export interface StrikethroughNode extends BaseNode {
+    type: 'strikethrough';
+    children: InlineNode[];
+}
+export interface FootnoteRefNode extends BaseNode {
+    type: 'footnote_ref';
+    label: string;
+    key: string;
+}
+export interface LinkNode extends BaseNode {
+    type: 'link';
+    destination: string;
+    title: string;
+    children: InlineNode[];
+}
+export interface ImageNode extends BaseNode {
+    type: 'image';
+    destination: string;
+    title: string;
+    alt: string;
+}
+export interface HtmlInlineNode extends BaseNode {
+    type: 'html_inline';
+    literal: string;
+}
+export type InlineNode = TextNode | SoftbreakNode | HardbreakNode | CodeSpanNode | EmphasisNode | StrongNode | StrikethroughNode | FootnoteRefNode | LinkNode | ImageNode | HtmlInlineNode;
+export interface FootnoteDefinition {
+    label: string;
+    blocks: BlockNode[];
+}
+export interface ParseOptions {
+    sourcepos?: boolean;
+    extensions?: string[];
+}
+export interface RenderOptions {
+    softbreak?: string;
+    safe?: boolean;
+    tablePreferStyleAttributes?: boolean;
+    fullInfoString?: boolean;
+    smart?: boolean;
+    tagfilter?: boolean;
+    extensions?: string[];
+}

package/dist/parser/types.js

@@ -0,0 +1,5 @@
+"use strict";
+/**
+ * Type definitions for the Markdown AST nodes and parser/render options.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/parser/utils.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Shared text-processing utilities for the parser, including entity decoding, escaping,
+ * whitespace handling, and URI normalization.
+ */
+export declare function decodeHtmlEntities(str: string): string;
+export declare function escapeXml(str: string): string;
+export declare function escapeHtml(str: string, preserveEntities?: boolean): string;
+export declare const ASCII_PUNCTUATION_REGEX: RegExp;
+export declare const ASCII_PUNCTUATION_CHARS = "!\"#$%&'()*+,-./:;<=>?@[\\]^_`{|}~";
+export declare function isAsciiPunctuation(char: string): boolean;
+export declare function isWhitespace(char: string): boolean;
+export declare function isUnicodeWhitespace(char: string): boolean;
+export declare function isUnicodePunctuation(char: string): boolean;
+export declare function normalizeLineEndings(str: string): string;
+export declare function expandTabs(line: string, tabStop?: number): string;
+export declare function expandTabsPartial(line: string, startColumn: number, tabStop?: number): string;
+export declare function trimLeadingSpaces(line: string, max?: number): {
+    trimmed: string;
+    count: number;
+};
+export declare function countLeadingSpaces(line: string): number;
+export declare function countLeadingChars(line: string): {
+    spaces: number;
+    chars: number;
+};
+export declare function removeIndent(line: string, indent: number): string;
+export declare function extractContentAfterMarker(line: string, startColumn: number, charIndex: number): string;
+export declare function normalizeUri(uri: string): string;
+export declare function unescapeString(str: string): string;
+export declare function normalizeLabel(label: string): string;
+export declare function isTagFilterTag(tagName: string): boolean;
+export declare function applyTagFilter(html: string): string;