emdp 1.0.0

package/dist/cjs/parser/utils.js

@@ -0,0 +1,277 @@
+"use strict";
+/**
+ * Shared text-processing utilities for the parser, including entity decoding, escaping,
+ * whitespace handling, and URI normalization.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ASCII_PUNCTUATION_CHARS = exports.ASCII_PUNCTUATION_REGEX = void 0;
+exports.decodeHtmlEntities = decodeHtmlEntities;
+exports.escapeXml = escapeXml;
+exports.escapeHtml = escapeHtml;
+exports.isAsciiPunctuation = isAsciiPunctuation;
+exports.isWhitespace = isWhitespace;
+exports.isUnicodeWhitespace = isUnicodeWhitespace;
+exports.isUnicodePunctuation = isUnicodePunctuation;
+exports.normalizeLineEndings = normalizeLineEndings;
+exports.expandTabs = expandTabs;
+exports.expandTabsPartial = expandTabsPartial;
+exports.trimLeadingSpaces = trimLeadingSpaces;
+exports.countLeadingSpaces = countLeadingSpaces;
+exports.countLeadingChars = countLeadingChars;
+exports.removeIndent = removeIndent;
+exports.extractContentAfterMarker = extractContentAfterMarker;
+exports.normalizeUri = normalizeUri;
+exports.unescapeString = unescapeString;
+exports.normalizeLabel = normalizeLabel;
+exports.isTagFilterTag = isTagFilterTag;
+exports.applyTagFilter = applyTagFilter;
+const entities_js_1 = require("./entities.js");
+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 (entities_js_1.HTML_ENTITIES[capture]) {
+            return entities_js_1.HTML_ENTITIES[capture];
+        }
+        return match;
+    });
+}
+function escapeXml(str) {
+    return str
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+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);
+}
+exports.ASCII_PUNCTUATION_REGEX = /[!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~]/;
+exports.ASCII_PUNCTUATION_CHARS = '!"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~';
+function isAsciiPunctuation(char) {
+    return exports.ASCII_PUNCTUATION_REGEX.test(char);
+}
+function isWhitespace(char) {
+    return char === ' ' || char === '\t' || char === '\n' || char === '\r' || char === '\f';
+}
+function isUnicodeWhitespace(char) {
+    return /\s/.test(char);
+}
+function isUnicodePunctuation(char) {
+    return /[\p{P}\p{S}]/u.test(char);
+}
+function normalizeLineEndings(str) {
+    return str.replace(/\r\n?/g, '\n');
+}
+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;
+}
+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;
+}
+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 };
+}
+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;
+}
+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 };
+}
+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;
+}
+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);
+}
+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;
+    }
+}
+function unescapeString(str) {
+    return str.replace(/\\([!"#$%&'()*+,\-./:;<=>?@\[\\\]^_`{|}~])/g, '$1');
+}
+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',
+]);
+function isTagFilterTag(tagName) {
+    return TAG_FILTER.has(tagName.toLowerCase());
+}
+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/cli.d.ts

@@ -0,0 +1,6 @@
+#!/usr/bin/env node
+/**
+ * Command-line interface for the Markdown parser that reads Markdown from stdin and writes rendered
+ * HTML to stdout with optional GFM flags.
+ */
+export {};

package/dist/cli.js

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * Command-line interface for the Markdown parser that reads Markdown from stdin and writes rendered
+ * HTML to stdout with optional GFM flags.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const index_js_1 = require("./parser/index.js");
+const index_js_2 = require("./parser/gfm/index.js");
+const args = process.argv.slice(2);
+const extensions = [];
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-e' && i + 1 < args.length) {
+        extensions.push(args[i + 1]);
+        i++;
+    }
+}
+const useGfm = args.includes('--gfm') || extensions.length > 0;
+const renderOptions = {
+    tablePreferStyleAttributes: args.includes('--table-prefer-style-attributes') ||
+        extensions.includes('table-prefer-style-attributes'),
+    fullInfoString: args.includes('--full-info-string') || extensions.includes('full-info-string'),
+    smart: args.includes('--smart') || extensions.includes('smart'),
+    softbreak: '\n',
+};
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+    input += chunk;
+});
+process.stdin.on('end', () => {
+    const html = useGfm
+        ? (0, index_js_2.gfm)(input, { ...renderOptions, extensions })
+        : (0, index_js_1.markdown)(input, renderOptions);
+    process.stdout.write(html);
+});

package/dist/esm/cli.js

@@ -0,0 +1,34 @@
+#!/usr/bin/env node
+/**
+ * Command-line interface for the Markdown parser that reads Markdown from stdin and writes rendered
+ * HTML to stdout with optional GFM flags.
+ */
+import { markdown } from './parser/index.js';
+import { gfm } from './parser/gfm/index.js';
+const args = process.argv.slice(2);
+const extensions = [];
+for (let i = 0; i < args.length; i++) {
+    if (args[i] === '-e' && i + 1 < args.length) {
+        extensions.push(args[i + 1]);
+        i++;
+    }
+}
+const useGfm = args.includes('--gfm') || extensions.length > 0;
+const renderOptions = {
+    tablePreferStyleAttributes: args.includes('--table-prefer-style-attributes') ||
+        extensions.includes('table-prefer-style-attributes'),
+    fullInfoString: args.includes('--full-info-string') || extensions.includes('full-info-string'),
+    smart: args.includes('--smart') || extensions.includes('smart'),
+    softbreak: '\n',
+};
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => {
+    input += chunk;
+});
+process.stdin.on('end', () => {
+    const html = useGfm
+        ? gfm(input, { ...renderOptions, extensions })
+        : markdown(input, renderOptions);
+    process.stdout.write(html);
+});

package/dist/esm/gfm.js

@@ -0,0 +1,5 @@
+/**
+ * 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';

package/dist/esm/index.js

@@ -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/esm/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "module"
+}