emdp 1.0.0

package/dist/cjs/parser/inlines/autolink-extended.js

@@ -0,0 +1,364 @@
+"use strict";
+/**
+ * Parser for GFM extended autolinks that recognize bare URLs and emails.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseWwwAutolink = parseWwwAutolink;
+exports.parseUrlAutolink = parseUrlAutolink;
+exports.parseEmailAutolink = parseEmailAutolink;
+exports.parseProtocolAutolink = parseProtocolAutolink;
+exports.parseExtendedAutolink = parseExtendedAutolink;
+const VALID_PRECEDING_CHARS = new Set([
+    '\n', ' ', '\t', '*', '_', '~', '(', '"', "'",
+]);
+const VALID_EMAIL_PRECEDING_CHARS = new Set([
+    '\n', ' ', '\t', '*', '_', '~', '(', '"', "'", ':', '/',
+]);
+function isValidPrecedingChar(char) {
+    if (char === undefined)
+        return true;
+    return VALID_PRECEDING_CHARS.has(char);
+}
+function isValidEmailPrecedingChar(char) {
+    if (char === undefined)
+        return true;
+    return VALID_EMAIL_PRECEDING_CHARS.has(char);
+}
+function precededByOpenAngle(text, pos) {
+    let i = pos - 1;
+    while (i >= 0 && (text[i] === ' ' || text[i] === '\t' || text[i] === '\n')) {
+        i--;
+    }
+    return i >= 0 && text[i] === '<';
+}
+function isDomainChar(char) {
+    if (/[a-zA-Z0-9_-]/.test(char))
+        return true;
+    const code = char.codePointAt(0);
+    return code !== undefined && code > 127;
+}
+function isHighSurrogate(code) {
+    return code >= 0xD800 && code <= 0xDBFF;
+}
+function parseValidDomain(text, startPos, requirePeriod = true) {
+    let pos = startPos;
+    const segments = [];
+    let currentSegment = '';
+    while (pos < text.length) {
+        const char = text[pos];
+        const code = char.charCodeAt(0);
+        if (isHighSurrogate(code) && pos + 1 < text.length) {
+            const fullChar = text.slice(pos, pos + 2);
+            currentSegment += fullChar;
+            pos += 2;
+        }
+        else if (isDomainChar(char)) {
+            currentSegment += char;
+            pos++;
+        }
+        else if (char === '.') {
+            if (currentSegment.length === 0)
+                break;
+            segments.push(currentSegment);
+            currentSegment = '';
+            pos++;
+        }
+        else {
+            break;
+        }
+    }
+    if (currentSegment.length > 0) {
+        segments.push(currentSegment);
+    }
+    if (requirePeriod && segments.length < 2)
+        return null;
+    if (!requirePeriod && segments.length < 1)
+        return null;
+    if (segments.length >= 2) {
+        const lastTwo = segments.slice(-2);
+        for (const seg of lastTwo) {
+            if (seg.includes('_'))
+                return null;
+        }
+    }
+    return {
+        domain: segments.join('.'),
+        endPos: pos,
+    };
+}
+function trimAutolinkPath(url) {
+    let result = url;
+    const ltIndex = result.indexOf('<');
+    if (ltIndex !== -1) {
+        result = result.slice(0, ltIndex);
+    }
+    while (result.length > 0) {
+        const lastChar = result[result.length - 1];
+        if ('?!.,:*_~"\''.includes(lastChar)) {
+            result = result.slice(0, -1);
+            continue;
+        }
+        if (lastChar === ')') {
+            const openCount = (result.match(/\(/g) || []).length;
+            const closeCount = (result.match(/\)/g) || []).length;
+            if (closeCount > openCount) {
+                result = result.slice(0, -1);
+                continue;
+            }
+        }
+        if (lastChar === ';') {
+            const entityMatch = result.match(/&[a-zA-Z0-9]+;$/);
+            if (entityMatch) {
+                result = result.slice(0, -entityMatch[0].length);
+                continue;
+            }
+        }
+        break;
+    }
+    return result;
+}
+function parseWwwAutolink(text, pos, charBefore) {
+    if (!isValidPrecedingChar(charBefore))
+        return null;
+    if (precededByOpenAngle(text, pos))
+        return null;
+    if (!text.slice(pos).toLowerCase().startsWith('www.'))
+        return null;
+    const domainStart = pos + 4;
+    const domainResult = parseValidDomain(text, domainStart, true);
+    if (!domainResult)
+        return null;
+    let endPos = domainResult.endPos;
+    while (endPos < text.length) {
+        const char = text[endPos];
+        if (char === ' ' || char === '\t' || char === '\n' || char === '<')
+            break;
+        endPos++;
+    }
+    const fullMatch = text.slice(pos, endPos);
+    const trimmedUrl = trimAutolinkPath(fullMatch);
+    if (trimmedUrl.length <= 4)
+        return null;
+    return {
+        node: {
+            type: 'link',
+            destination: 'http://' + trimmedUrl,
+            title: '',
+            children: [{ type: 'text', literal: trimmedUrl }],
+        },
+        length: trimmedUrl.length,
+    };
+}
+function parseUrlAutolink(text, pos, charBefore) {
+    if (!isValidPrecedingChar(charBefore))
+        return null;
+    if (precededByOpenAngle(text, pos))
+        return null;
+    const remaining = text.slice(pos);
+    let scheme = null;
+    if (remaining.toLowerCase().startsWith('https://')) {
+        scheme = 'https://';
+    }
+    else if (remaining.toLowerCase().startsWith('http://')) {
+        scheme = 'http://';
+    }
+    else if (remaining.toLowerCase().startsWith('ftp://')) {
+        scheme = 'ftp://';
+    }
+    if (!scheme)
+        return null;
+    const domainStart = pos + scheme.length;
+    const domainResult = parseValidDomain(text, domainStart, false);
+    if (!domainResult)
+        return null;
+    let endPos = domainResult.endPos;
+    while (endPos < text.length) {
+        const char = text[endPos];
+        if (char === ' ' || char === '\t' || char === '\n' || char === '<')
+            break;
+        endPos++;
+    }
+    const fullMatch = text.slice(pos, endPos);
+    const trimmedUrl = trimAutolinkPath(fullMatch);
+    if (trimmedUrl.length <= scheme.length)
+        return null;
+    return {
+        node: {
+            type: 'link',
+            destination: trimmedUrl,
+            title: '',
+            children: [{ type: 'text', literal: trimmedUrl }],
+        },
+        length: trimmedUrl.length,
+    };
+}
+function parseEmailAutolink(text, pos, charBefore) {
+    if (!isValidEmailPrecedingChar(charBefore))
+        return null;
+    if (precededByOpenAngle(text, pos))
+        return null;
+    let localEnd = pos;
+    while (localEnd < text.length) {
+        const char = text[localEnd];
+        if (/[a-zA-Z0-9.\-_+]/.test(char)) {
+            localEnd++;
+        }
+        else {
+            break;
+        }
+    }
+    if (localEnd === pos)
+        return null;
+    if (text[localEnd] !== '@')
+        return null;
+    const localPart = text.slice(pos, localEnd);
+    const domainStart = localEnd + 1;
+    let domainEnd = domainStart;
+    let lastDotPos = -1;
+    let segmentStart = domainStart;
+    while (domainEnd < text.length) {
+        const char = text[domainEnd];
+        if (/[a-zA-Z0-9\-_]/.test(char)) {
+            domainEnd++;
+        }
+        else if (char === '.') {
+            if (domainEnd === segmentStart)
+                break;
+            lastDotPos = domainEnd;
+            segmentStart = domainEnd + 1;
+            domainEnd++;
+        }
+        else {
+            break;
+        }
+    }
+    if (lastDotPos === -1)
+        return null;
+    const lastDomainChar = text[domainEnd - 1];
+    if (lastDomainChar === '-' || lastDomainChar === '_')
+        return null;
+    let finalEnd = domainEnd;
+    while (finalEnd > domainStart && text[finalEnd - 1] === '.') {
+        finalEnd--;
+    }
+    const domain = text.slice(domainStart, finalEnd);
+    if (!domain.includes('.'))
+        return null;
+    const email = localPart + '@' + domain;
+    return {
+        node: {
+            type: 'link',
+            destination: 'mailto:' + email,
+            title: '',
+            children: [{ type: 'text', literal: email }],
+        },
+        length: email.length,
+    };
+}
+function parseProtocolAutolink(text, pos, charBefore) {
+    if (!isValidEmailPrecedingChar(charBefore))
+        return null;
+    if (precededByOpenAngle(text, pos))
+        return null;
+    const remaining = text.slice(pos);
+    let protocol = null;
+    if (remaining.toLowerCase().startsWith('mailto:')) {
+        protocol = 'mailto:';
+    }
+    else if (remaining.toLowerCase().startsWith('xmpp:')) {
+        protocol = 'xmpp:';
+    }
+    if (!protocol)
+        return null;
+    const emailStart = pos + protocol.length;
+    let localEnd = emailStart;
+    while (localEnd < text.length) {
+        const char = text[localEnd];
+        if (/[a-zA-Z0-9.\-_+]/.test(char)) {
+            localEnd++;
+        }
+        else {
+            break;
+        }
+    }
+    if (localEnd === emailStart)
+        return null;
+    if (text[localEnd] !== '@')
+        return null;
+    const localPart = text.slice(emailStart, localEnd);
+    const domainStart = localEnd + 1;
+    let domainEnd = domainStart;
+    let lastDotPos = -1;
+    let segmentStart = domainStart;
+    while (domainEnd < text.length) {
+        const char = text[domainEnd];
+        if (/[a-zA-Z0-9\-_]/.test(char)) {
+            domainEnd++;
+        }
+        else if (char === '.') {
+            if (domainEnd === segmentStart)
+                break;
+            lastDotPos = domainEnd;
+            segmentStart = domainEnd + 1;
+            domainEnd++;
+        }
+        else {
+            break;
+        }
+    }
+    if (lastDotPos === -1)
+        return null;
+    const lastDomainChar = text[domainEnd - 1];
+    if (lastDomainChar === '-' || lastDomainChar === '_')
+        return null;
+    let finalEnd = domainEnd;
+    while (finalEnd > domainStart && text[finalEnd - 1] === '.') {
+        finalEnd--;
+    }
+    const domain = text.slice(domainStart, finalEnd);
+    if (!domain.includes('.'))
+        return null;
+    let fullUrl = protocol + localPart + '@' + domain;
+    let consumedLength = fullUrl.length;
+    if (protocol === 'xmpp:' && finalEnd < text.length && text[finalEnd] === '/') {
+        let resourceEnd = finalEnd + 1;
+        while (resourceEnd < text.length) {
+            const char = text[resourceEnd];
+            if (/[a-zA-Z0-9@.]/.test(char)) {
+                resourceEnd++;
+            }
+            else {
+                break;
+            }
+        }
+        if (resourceEnd > finalEnd + 1) {
+            let resource = text.slice(finalEnd, resourceEnd);
+            const secondSlash = resource.indexOf('/', 1);
+            if (secondSlash !== -1) {
+                resource = resource.slice(0, secondSlash);
+            }
+            while (resource.length > 1 && '?!.,:*_~'.includes(resource[resource.length - 1])) {
+                resource = resource.slice(0, -1);
+            }
+            if (resource.length > 1) {
+                fullUrl += resource;
+                consumedLength = fullUrl.length;
+            }
+        }
+    }
+    return {
+        node: {
+            type: 'link',
+            destination: fullUrl,
+            title: '',
+            children: [{ type: 'text', literal: fullUrl }],
+        },
+        length: consumedLength,
+    };
+}
+function parseExtendedAutolink(text, pos, charBefore) {
+    return (parseProtocolAutolink(text, pos, charBefore) ||
+        parseUrlAutolink(text, pos, charBefore) ||
+        parseWwwAutolink(text, pos, charBefore) ||
+        parseEmailAutolink(text, pos, charBefore));
+}

package/dist/cjs/parser/inlines/autolink.js

@@ -0,0 +1,44 @@
+"use strict";
+/**
+ * Parser for autolinks enclosed in angle brackets.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseAutolink = parseAutolink;
+exports.isAutolinkStart = isAutolinkStart;
+const AUTOLINK_URI_REGEX = /^<([a-zA-Z][a-zA-Z0-9+.-]{1,31}:[^\s<>]*)>/;
+const AUTOLINK_EMAIL_REGEX = /^<([a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*)>/;
+function parseAutolink(text, pos) {
+    if (text[pos] !== '<')
+        return null;
+    const remaining = text.slice(pos);
+    const uriMatch = remaining.match(AUTOLINK_URI_REGEX);
+    if (uriMatch) {
+        const uri = uriMatch[1];
+        return {
+            node: {
+                type: 'link',
+                destination: uri,
+                title: '',
+                children: [{ type: 'text', literal: uri }],
+            },
+            length: uriMatch[0].length,
+        };
+    }
+    const emailMatch = remaining.match(AUTOLINK_EMAIL_REGEX);
+    if (emailMatch) {
+        const email = emailMatch[1];
+        return {
+            node: {
+                type: 'link',
+                destination: `mailto:${email}`,
+                title: '',
+                children: [{ type: 'text', literal: email }],
+            },
+            length: emailMatch[0].length,
+        };
+    }
+    return null;
+}
+function isAutolinkStart(text, pos) {
+    return text[pos] === '<';
+}

package/dist/cjs/parser/inlines/code-span.js

@@ -0,0 +1,48 @@
+"use strict";
+/**
+ * Parser for inline code spans delimited by backticks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCodeSpan = parseCodeSpan;
+exports.isCodeSpanStart = isCodeSpanStart;
+function parseCodeSpan(text, pos) {
+    if (text[pos] !== '`')
+        return null;
+    let openingLength = 0;
+    let i = pos;
+    while (i < text.length && text[i] === '`') {
+        openingLength++;
+        i++;
+    }
+    let searchPos = i;
+    while (searchPos < text.length) {
+        const nextBacktick = text.indexOf('`', searchPos);
+        if (nextBacktick === -1)
+            return null;
+        let closingLength = 0;
+        let j = nextBacktick;
+        while (j < text.length && text[j] === '`') {
+            closingLength++;
+            j++;
+        }
+        if (closingLength === openingLength) {
+            let content = text.slice(i, nextBacktick);
+            content = content.replace(/\n/g, ' ');
+            if (content.length >= 2 && content[0] === ' ' && content[content.length - 1] === ' ' && content.trim() !== '') {
+                content = content.slice(1, -1);
+            }
+            return {
+                node: {
+                    type: 'code_span',
+                    literal: content,
+                },
+                length: j - pos,
+            };
+        }
+        searchPos = j;
+    }
+    return null;
+}
+function isCodeSpanStart(text, pos) {
+    return text[pos] === '`';
+}

package/dist/cjs/parser/inlines/emphasis.js

@@ -0,0 +1,64 @@
+"use strict";
+/**
+ * Parser for emphasis and strong emphasis using * and _ delimiters.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseDelimiterRun = parseDelimiterRun;
+exports.isEmphasisDelimiter = isEmphasisDelimiter;
+exports.canDelimitersMatch = canDelimitersMatch;
+const utils_js_1 = require("../utils.js");
+function parseDelimiterRun(text, pos) {
+    const char = text[pos];
+    if (char !== '*' && char !== '_')
+        return null;
+    let length = 0;
+    let i = pos;
+    while (i < text.length && text[i] === char) {
+        length++;
+        i++;
+    }
+    const charBefore = pos > 0 ? text[pos - 1] : '\n';
+    const charAfter = i < text.length ? text[i] : '\n';
+    const beforeIsWhitespace = (0, utils_js_1.isUnicodeWhitespace)(charBefore) || charBefore === '\n';
+    const afterIsWhitespace = (0, utils_js_1.isUnicodeWhitespace)(charAfter) || charAfter === '\n';
+    const beforeIsPunctuation = (0, utils_js_1.isUnicodePunctuation)(charBefore);
+    const afterIsPunctuation = (0, utils_js_1.isUnicodePunctuation)(charAfter);
+    const leftFlanking = !afterIsWhitespace &&
+        (!afterIsPunctuation || beforeIsWhitespace || beforeIsPunctuation);
+    const rightFlanking = !beforeIsWhitespace &&
+        (!beforeIsPunctuation || afterIsWhitespace || afterIsPunctuation);
+    let canOpen;
+    let canClose;
+    if (char === '*') {
+        canOpen = leftFlanking;
+        canClose = rightFlanking;
+    }
+    else {
+        canOpen = leftFlanking && (!rightFlanking || beforeIsPunctuation);
+        canClose = rightFlanking && (!leftFlanking || afterIsPunctuation);
+    }
+    return {
+        char: char,
+        length,
+        canOpen,
+        canClose,
+        position: pos,
+        origLength: length,
+    };
+}
+function isEmphasisDelimiter(text, pos) {
+    const char = text[pos];
+    return char === '*' || char === '_';
+}
+function canDelimitersMatch(opener, closer) {
+    if (opener.char !== closer.char)
+        return false;
+    if ((opener.canOpen && opener.canClose) || (closer.canOpen && closer.canClose)) {
+        if ((opener.origLength + closer.origLength) % 3 === 0) {
+            if (opener.origLength % 3 !== 0 || closer.origLength % 3 !== 0) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/cjs/parser/inlines/entity.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Parser for HTML character entities in inline content.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEntity = parseEntity;
+exports.isEntityStart = isEntityStart;
+const utils_js_1 = require("../utils.js");
+const ENTITY_REGEX = /^&(?:#[xX][0-9a-fA-F]{1,6}|#[0-9]{1,7}|[a-zA-Z][a-zA-Z0-9]{0,31});/;
+function parseEntity(text, pos) {
+    if (text[pos] !== '&')
+        return null;
+    const remaining = text.slice(pos);
+    const match = remaining.match(ENTITY_REGEX);
+    if (!match)
+        return null;
+    const entity = match[0];
+    const decoded = (0, utils_js_1.decodeHtmlEntities)(entity);
+    if (decoded === entity)
+        return null;
+    return { char: decoded, length: entity.length };
+}
+function isEntityStart(text, pos) {
+    return text[pos] === '&';
+}

package/dist/cjs/parser/inlines/escape.js

@@ -0,0 +1,25 @@
+"use strict";
+/**
+ * Parser for backslash escape sequences and escaped hard breaks.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseEscape = parseEscape;
+exports.isEscapedChar = isEscapedChar;
+const utils_js_1 = require("../utils.js");
+function parseEscape(text, pos) {
+    if (text[pos] !== '\\')
+        return null;
+    if (pos + 1 >= text.length)
+        return null;
+    const nextChar = text[pos + 1];
+    if (nextChar === '\n') {
+        return { char: '\n', length: 2 };
+    }
+    if ((0, utils_js_1.isAsciiPunctuation)(nextChar)) {
+        return { char: nextChar, length: 2 };
+    }
+    return null;
+}
+function isEscapedChar(text, pos) {
+    return parseEscape(text, pos) !== null;
+}

package/dist/cjs/parser/inlines/footnote.js

@@ -0,0 +1,41 @@
+"use strict";
+/**
+ * Parser for GFM footnote labels.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFootnoteLabel = parseFootnoteLabel;
+const utils_js_1 = require("../utils.js");
+function parseFootnoteLabel(text, pos) {
+    if (text[pos] !== '[' || text[pos + 1] !== '^')
+        return null;
+    let i = pos + 2;
+    let label = '';
+    while (i < text.length) {
+        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 === ']') {
+            break;
+        }
+        label += char;
+        i++;
+    }
+    if (i >= text.length || text[i] !== ']')
+        return null;
+    if (label.length === 0 || label.length > 999)
+        return null;
+    return {
+        label,
+        normalized: (0, utils_js_1.normalizeLabel)(label),
+        length: i - pos + 1,
+    };
+}

package/dist/cjs/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/cjs/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; } });