emdp 1.0.0

package/dist/parser/inlines/hard-break.js

@@ -0,0 +1,45 @@
+"use strict";
+/**
+ * Parser for hard line breaks created by backslash-newline or trailing spaces.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseHardBreak = parseHardBreak;
+exports.isHardBreakStart = isHardBreakStart;
+function parseHardBreak(text, pos) {
+    if (text[pos] === '\\' && text[pos + 1] === '\n') {
+        return {
+            node: { type: 'hardbreak' },
+            length: 2,
+        };
+    }
+    if (text[pos] === ' ') {
+        let spaces = 0;
+        let i = pos;
+        while (i < text.length && text[i] === ' ') {
+            spaces++;
+            i++;
+        }
+        if (spaces >= 2 && text[i] === '\n') {
+            return {
+                node: { type: 'hardbreak' },
+                length: spaces + 1,
+            };
+        }
+    }
+    return null;
+}
+function isHardBreakStart(text, pos) {
+    if (text[pos] === '\\' && text[pos + 1] === '\n')
+        return true;
+    if (text[pos] === ' ') {
+        let i = pos;
+        let spaces = 0;
+        while (i < text.length && text[i] === ' ') {
+            spaces++;
+            i++;
+        }
+        if (spaces >= 2 && text[i] === '\n')
+            return true;
+    }
+    return false;
+}

package/dist/parser/inlines/image.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Image parsing helpers that reuse link logic and create image nodes.
+ */
+export { createImageNode, isImageStart } from './link.js';

package/dist/parser/inlines/image.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Image parsing helpers that reuse link logic and create image nodes.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isImageStart = exports.createImageNode = void 0;
+var link_js_1 = require("./link.js");
+Object.defineProperty(exports, "createImageNode", { enumerable: true, get: function () { return link_js_1.createImageNode; } });
+Object.defineProperty(exports, "isImageStart", { enumerable: true, get: function () { return link_js_1.isImageStart; } });

package/dist/parser/inlines/link.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Parser for inline links and images, including destinations, titles, and reference labels.
+ */
+import type { LinkNode, ImageNode } from '../types.js';
+export interface LinkMatch {
+    type: 'link' | 'image';
+    destination: string;
+    title: string;
+    textStart: number;
+    textEnd: number;
+    fullEnd: number;
+}
+export declare function parseLinkDestination(text: string): {
+    destination: string;
+    length: number;
+} | null;
+export declare function parseLinkTitle(text: string): {
+    title: string;
+    length: number;
+} | null;
+export declare function parseInlineLink(text: string, pos: number): {
+    destination: string;
+    title: string;
+    length: number;
+} | null;
+export declare function parseLinkLabel(text: string, pos: number): {
+    label: string;
+    length: number;
+} | null;
+export declare function createLinkNode(destination: string, title: string): LinkNode;
+export declare function createImageNode(destination: string, title: string, alt: string): ImageNode;
+export declare function isLinkStart(text: string, pos: number): boolean;
+export declare function isImageStart(text: string, pos: number): boolean;

package/dist/parser/inlines/link.js

@@ -0,0 +1,166 @@
+"use strict";
+/**
+ * Parser for inline links and images, including destinations, titles, and reference labels.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseLinkDestination = parseLinkDestination;
+exports.parseLinkTitle = parseLinkTitle;
+exports.parseInlineLink = parseInlineLink;
+exports.parseLinkLabel = parseLinkLabel;
+exports.createLinkNode = createLinkNode;
+exports.createImageNode = createImageNode;
+exports.isLinkStart = isLinkStart;
+exports.isImageStart = isImageStart;
+const utils_js_1 = require("../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 = /^(?:"((?:[^"\\]|\\.)*)"|'((?:[^'\\]|\\.)*)'|\(([^()\\]*(?:\\.[^()\\]*)*)\))/;
+function parseLinkDestination(text) {
+    if (text[0] === '<') {
+        const match = text.match(LINK_DESTINATION_ANGLE_REGEX);
+        if (match) {
+            return {
+                destination: (0, utils_js_1.decodeHtmlEntities)((0, utils_js_1.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: (0, utils_js_1.decodeHtmlEntities)((0, utils_js_1.unescapeString)(text.slice(0, i))),
+        length: i,
+    };
+}
+function parseLinkTitle(text) {
+    const match = text.match(LINK_TITLE_REGEX);
+    if (!match)
+        return null;
+    const title = match[1] ?? match[2] ?? match[3] ?? '';
+    return {
+        title: (0, utils_js_1.decodeHtmlEntities)((0, utils_js_1.unescapeString)(title)),
+        length: match[0].length,
+    };
+}
+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 };
+}
+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: (0, utils_js_1.normalizeLabel)(label), length: i - pos + 1 };
+}
+function createLinkNode(destination, title) {
+    return {
+        type: 'link',
+        destination,
+        title,
+        children: [],
+    };
+}
+function createImageNode(destination, title, alt) {
+    return {
+        type: 'image',
+        destination,
+        title,
+        alt,
+    };
+}
+function isLinkStart(text, pos) {
+    return text[pos] === '[';
+}
+function isImageStart(text, pos) {
+    return text[pos] === '!' && text[pos + 1] === '[';
+}

package/dist/parser/inlines/soft-break.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Parser for soft line breaks created by single newlines.
+ */
+import type { SoftbreakNode } from '../types.js';
+export declare function parseSoftBreak(text: string, pos: number): {
+    node: SoftbreakNode;
+    length: number;
+} | null;
+export declare function isSoftBreak(text: string, pos: number): boolean;

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

@@ -0,0 +1,18 @@
+"use strict";
+/**
+ * Parser for soft line breaks created by single newlines.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSoftBreak = parseSoftBreak;
+exports.isSoftBreak = isSoftBreak;
+function parseSoftBreak(text, pos) {
+    if (text[pos] !== '\n')
+        return null;
+    return {
+        node: { type: 'softbreak' },
+        length: 1,
+    };
+}
+function isSoftBreak(text, pos) {
+    return text[pos] === '\n';
+}

package/dist/parser/inlines/strikethrough.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Parser for GFM strikethrough using ~ delimiters.
+ */
+import type { StrikethroughNode, InlineNode } from '../types.js';
+export interface StrikethroughDelimiter {
+    char: '~';
+    length: number;
+    canOpen: boolean;
+    canClose: boolean;
+    position: number;
+    origLength: number;
+}
+export declare function parseStrikethroughDelimiter(text: string, pos: number): StrikethroughDelimiter | null;
+export declare function isStrikethroughDelimiter(text: string, pos: number): boolean;
+export declare function createStrikethroughNode(children?: InlineNode[]): StrikethroughNode;
+export declare function canStrikethroughDelimitersMatch(opener: StrikethroughDelimiter, closer: StrikethroughDelimiter): boolean;

package/dist/parser/inlines/strikethrough.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Parser for GFM strikethrough using ~ delimiters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseStrikethroughDelimiter = parseStrikethroughDelimiter;
+exports.isStrikethroughDelimiter = isStrikethroughDelimiter;
+exports.createStrikethroughNode = createStrikethroughNode;
+exports.canStrikethroughDelimitersMatch = canStrikethroughDelimitersMatch;
+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,
+    };
+}
+function isStrikethroughDelimiter(text, pos) {
+    return text[pos] === '~';
+}
+function createStrikethroughNode(children = []) {
+    return {
+        type: 'strikethrough',
+        children,
+    };
+}
+function canStrikethroughDelimitersMatch(opener, closer) {
+    return opener.length === closer.length;
+}

package/dist/parser/inlines/text.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Text node factories for literal inline content.
+ */
+import type { TextNode } from '../types.js';
+export declare function createTextNode(literal: string, noDelim?: boolean): TextNode;
+export declare function mergeTextNodes(nodes: TextNode[]): TextNode;

package/dist/parser/inlines/text.js

@@ -0,0 +1,20 @@
+"use strict";
+/**
+ * Text node factories for literal inline content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTextNode = createTextNode;
+exports.mergeTextNodes = mergeTextNodes;
+function createTextNode(literal, noDelim = false) {
+    return {
+        type: 'text',
+        literal,
+        ...(noDelim ? { noDelim: true } : {}),
+    };
+}
+function mergeTextNodes(nodes) {
+    return {
+        type: 'text',
+        literal: nodes.map(n => n.literal).join(''),
+    };
+}

package/dist/parser/renderer.d.ts

@@ -0,0 +1,33 @@
+/**
+ * HTML renderer that converts a Markdown AST into HTML with configurable list, URL safety,
+ * and soft-break handling.
+ */
+import type { DocumentNode, RenderOptions } from './types.js';
+export declare class HtmlRenderer {
+    private options;
+    constructor(options?: RenderOptions);
+    render(document: DocumentNode): string;
+    private renderBlocks;
+    private renderBlock;
+    private renderParagraph;
+    private renderHeading;
+    private renderThematicBreak;
+    private renderCodeBlock;
+    private renderBlockquote;
+    private renderList;
+    private renderListItem;
+    private renderHtmlBlock;
+    private renderInlines;
+    private renderInline;
+    private renderText;
+    private renderSoftbreak;
+    private renderHardbreak;
+    private renderCodeSpan;
+    private renderEmphasis;
+    private renderStrong;
+    private renderLink;
+    private renderImage;
+    private renderHtmlInline;
+    private renderInlinesSmart;
+    private applyDashesAndEllipses;
+}