emdp 1.0.0

package/dist/esm/parser/utils.js

@@ -0,0 +1,254 @@
+/**
+ * Shared text-processing utilities for the parser, including entity decoding, escaping,
+ * whitespace handling, and URI normalization.
+ */
+import { HTML_ENTITIES } from './entities.js';
+export function decodeHtmlEntities(str) {
+    return str.replace(/&(#[xX]?[0-9a-fA-F]+|[a-zA-Z][a-zA-Z0-9]*);/g, (match, capture) => {
+        if (capture.startsWith('#x') || capture.startsWith('#X')) {
+            const code = parseInt(capture.slice(2), 16);
+            if (!isNaN(code) && code >= 0 && code <= 0x10ffff) {
+                if (code === 0)
+                    return '\uFFFD';
+                return String.fromCodePoint(code);
+            }
+        }
+        else if (capture.startsWith('#')) {
+            const code = parseInt(capture.slice(1), 10);
+            if (!isNaN(code) && code >= 0 && code <= 0x10ffff) {
+                if (code === 0)
+                    return '\uFFFD';
+                return String.fromCodePoint(code);
+            }
+        }
+        else if (HTML_ENTITIES[capture]) {
+            return HTML_ENTITIES[capture];
+        }
+        return match;
+    });
+}
+export function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+export function escapeHtml(str, preserveEntities = false) {
+    if (preserveEntities) {
+        return str
+            .replace(/&(?![#a-zA-Z0-9]+;)/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            .replace(/"/g, '&quot;');
+    }
+    return escapeXml(str);
+}
+export const ASCII_PUNCTUATION_REGEX = /[!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~]/;
+export const ASCII_PUNCTUATION_CHARS = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+export function isAsciiPunctuation(char) {
+    return ASCII_PUNCTUATION_REGEX.test(char);
+}
+export function isWhitespace(char) {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === '\f';
+}
+export function isUnicodeWhitespace(char) {
+    return /\s/.test(char);
+}
+export function isUnicodePunctuation(char) {
+    return /[\p{P}\p{S}]/u.test(char);
+}
+export function normalizeLineEndings(str) {
+    return str.replace(/\r\n?/g, '\n');
+}
+export function expandTabs(line, tabStop = 4) {
+    let result = '';
+    let column = 0;
+    for (const char of line) {
+        if (char === '\t') {
+            const spaces = tabStop - (column % tabStop);
+            result += ' '.repeat(spaces);
+            column += spaces;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+export function expandTabsPartial(line, startColumn, tabStop = 4) {
+    let result = '';
+    let column = startColumn;
+    for (const char of line) {
+        if (char === '\t') {
+            const spaces = tabStop - (column % tabStop);
+            result += ' '.repeat(spaces);
+            column += spaces;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+export function trimLeadingSpaces(line, max = 3) {
+    let count = 0;
+    let i = 0;
+    while (i < line.length && line[i] === ' ' && count < max) {
+        count++;
+        i++;
+    }
+    return { trimmed: line.slice(i), count };
+}
+export function countLeadingSpaces(line) {
+    let count = 0;
+    for (const char of line) {
+        if (char === ' ')
+            count++;
+        else if (char === '\t')
+            count += 4 - (count % 4);
+        else
+            break;
+    }
+    return count;
+}
+export function countLeadingChars(line) {
+    let spaces = 0;
+    let chars = 0;
+    for (const char of line) {
+        if (char === ' ') {
+            spaces++;
+            chars++;
+        }
+        else if (char === '\t') {
+            const tabWidth = 4 - (spaces % 4);
+            spaces += tabWidth;
+            chars++;
+        }
+        else {
+            break;
+        }
+    }
+    return { spaces, chars };
+}
+export function removeIndent(line, indent) {
+    let removed = 0;
+    let i = 0;
+    while (i < line.length && removed < indent) {
+        if (line[i] === ' ') {
+            removed++;
+            i++;
+        }
+        else if (line[i] === '\t') {
+            const tabWidth = 4 - (removed % 4);
+            if (removed + tabWidth <= indent) {
+                removed += tabWidth;
+                i++;
+            }
+            else {
+                const remaining = indent - removed;
+                const spacesFromTab = tabWidth - remaining;
+                const originalColumn = removed + tabWidth;
+                return ' '.repeat(spacesFromTab) + expandRestOfLine(line, i + 1, originalColumn);
+            }
+        }
+        else {
+            break;
+        }
+    }
+    return line.slice(i);
+}
+function expandRestOfLine(line, startIdx, startColumn) {
+    let result = '';
+    let column = startColumn;
+    for (let i = startIdx; i < line.length; i++) {
+        const char = line[i];
+        if (char === '\t') {
+            const tabWidth = 4 - (column % 4);
+            result += ' '.repeat(tabWidth);
+            column += tabWidth;
+        }
+        else {
+            result += char;
+            column++;
+        }
+    }
+    return result;
+}
+export function extractContentAfterMarker(line, startColumn, charIndex) {
+    if (charIndex > 0 && line[charIndex - 1] === '\t') {
+        let col = 0;
+        let idx = 0;
+        while (idx < charIndex - 1) {
+            if (line[idx] === '\t') {
+                col = col + (4 - (col % 4));
+            }
+            else {
+                col++;
+            }
+            idx++;
+        }
+        const tabEndColumn = col + (4 - (col % 4));
+        if (startColumn > col && startColumn < tabEndColumn) {
+            const remainingSpaces = tabEndColumn - startColumn;
+            return ' '.repeat(remainingSpaces) + line.slice(charIndex);
+        }
+    }
+    return line.slice(charIndex);
+}
+export function normalizeUri(uri) {
+    try {
+        let result = '';
+        let i = 0;
+        while (i < uri.length) {
+            const char = uri[i];
+            if (char === '%' && i + 2 < uri.length && /^[0-9a-fA-F]{2}$/.test(uri.slice(i + 1, i + 3))) {
+                result += uri.slice(i, i + 3).toUpperCase();
+                i += 3;
+            }
+            else {
+                const code = char.charCodeAt(0);
+                if (code > 0x7f || char === ' ') {
+                    result += encodeURIComponent(char);
+                }
+                else {
+                    result += char;
+                }
+                i++;
+            }
+        }
+        return result;
+    }
+    catch {
+        return uri;
+    }
+}
+export function unescapeString(str) {
+    return str.replace(/\\([!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~])/g, '$1');
+}
+export function normalizeLabel(label) {
+    return label
+        .trim()
+        .replace(/[ \t\r\n]+/g, ' ')
+        .replace(/\u1e9e/g, 'ss')
+        .toLowerCase();
+}
+const TAG_FILTER = new Set([
+    'title',
+    'textarea',
+    'style',
+    'xmp',
+    'iframe',
+    'noembed',
+    'noframes',
+    'script',
+    'plaintext',
+]);
+export function isTagFilterTag(tagName) {
+    return TAG_FILTER.has(tagName.toLowerCase());
+}
+export function applyTagFilter(html) {
+    return html.replace(/<(?=[ \t\n\r]*\/?[ \t\n\r]*(?:title|textarea|style|xmp|iframe|noembed|noframes|script|plaintext)\b)/gi, '&lt;');
+}

package/dist/gfm.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Entry point for GitHub Flavored Markdown that re-exports GFM helpers, renderer, and AST types.
+ */
+export * from './parser/gfm/index.js';
+export { default } from './parser/gfm/index.js';
+export type { DocumentNode, BlockNode, InlineNode, ParagraphNode, HeadingNode, ThematicBreakNode, CodeBlockNode, BlockquoteNode, ListNode, ListItemNode, HtmlBlockNode, TableNode, TableRowNode, TableCellNode, TableAlignment, TextNode, SoftbreakNode, HardbreakNode, CodeSpanNode, EmphasisNode, StrongNode, StrikethroughNode, LinkNode, ImageNode, HtmlInlineNode, ParseOptions, RenderOptions, } from './parser/types.js';

package/dist/gfm.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Entry point for GitHub Flavored Markdown that re-exports GFM helpers, renderer, and AST types.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+__exportStar(require("./parser/gfm/index.js"), exports);
+var index_js_1 = require("./parser/gfm/index.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_js_1).default; } });

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Main entry point for the CommonMark parser that re-exports public APIs.
+ */
+export * from './parser/index.js';
+export { default } from './parser/index.js';

package/dist/index.js

@@ -0,0 +1,26 @@
+"use strict";
+/**
+ * Main entry point for the CommonMark parser that re-exports public APIs.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = void 0;
+__exportStar(require("./parser/index.js"), exports);
+var index_js_1 = require("./parser/index.js");
+Object.defineProperty(exports, "default", { enumerable: true, get: function () { return __importDefault(index_js_1).default; } });

package/dist/parser/block-parser.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Block parsing phase that builds block nodes like paragraphs, headings, lists, code blocks,
+ * blockquotes, and HTML blocks while collecting link reference definitions.
+ */
+import type { DocumentNode, LinkReferenceDefinition } from './types.js';
+export declare class BlockParser {
+    private lines;
+    private lineIndex;
+    private linkReferences;
+    private static readonly LAZY_PREFIX;
+    parse(input: string): {
+        document: DocumentNode;
+        linkReferences: Map<string, LinkReferenceDefinition>;
+    };
+    private currentLine;
+    private advance;
+    private parseBlocks;
+    private parseList;
+    private parseListItem;
+    private lastNonBlankLine;
+    private getBlockquotePrefix;
+    private allowsLazyAfterListMarker;
+    private extractBlockquoteContent;
+    private extractListItemContent;
+}